Coverage Report

Generated on Fri, 17 Nov 2023 16:44:20 CST with gocov-html

Report Overview

`github.com/wfusion/gofusion/async`	`68.8%`	`232/337`
`github.com/wfusion/gofusion/cache`	`76.9%`	`223/290`
`github.com/wfusion/gofusion/common/constant`	`75.0%`	`3/4`
`github.com/wfusion/gofusion/common/di`	`69.0%`	`40/58`
`github.com/wfusion/gofusion/common/env`	`61.9%`	`13/21`
`github.com/wfusion/gofusion/common/infra/drivers/mongo`	`89.1%`	`41/46`
`github.com/wfusion/gofusion/common/infra/drivers/orm`	`75.3%`	`55/73`
`github.com/wfusion/gofusion/common/infra/drivers/orm/idgen`	`87.5%`	`21/24`
`github.com/wfusion/gofusion/common/infra/drivers/redis`	`47.1%`	`32/68`
`github.com/wfusion/gofusion/common/utils`	`56.4%`	`514/912`
`github.com/wfusion/gofusion/common/utils/cipher`	`85.6%`	`357/417`
`github.com/wfusion/gofusion/common/utils/clone`	`37.3%`	`281/753`
`github.com/wfusion/gofusion/common/utils/cmp`	`23.1%`	`33/143`
`github.com/wfusion/gofusion/common/utils/compress`	`73.7%`	`101/137`
`github.com/wfusion/gofusion/common/utils/encode`	`84.3%`	`167/198`
`github.com/wfusion/gofusion/common/utils/inspect`	`67.7%`	`67/99`
`github.com/wfusion/gofusion/common/utils/serialize`	`66.7%`	`70/105`
`github.com/wfusion/gofusion/config`	`79.5%`	`345/434`
`github.com/wfusion/gofusion/context`	`75.0%`	`87/116`
`github.com/wfusion/gofusion/cron`	`76.8%`	`251/327`
`github.com/wfusion/gofusion/db`	`51.8%`	`307/593`
`github.com/wfusion/gofusion/db/callbacks`	`44.0%`	`70/159`
`github.com/wfusion/gofusion/db/plugins`	`61.0%`	`407/667`
`github.com/wfusion/gofusion/db/softdelete`	`59.0%`	`72/122`
`github.com/wfusion/gofusion/http`	`68.3%`	`426/624`
`github.com/wfusion/gofusion/http/consts`	`88.9%`	`8/9`
`github.com/wfusion/gofusion/http/gracefully`	`37.8%`	`88/233`
`github.com/wfusion/gofusion/http/middleware`	`53.3%`	`97/182`
`github.com/wfusion/gofusion/http/parser`	`47.4%`	`144/304`
`github.com/wfusion/gofusion/i18n`	`57.0%`	`49/86`
`github.com/wfusion/gofusion/internal/configor`	`59.3%`	`147/248`
`github.com/wfusion/gofusion/internal/util/payload`	`60.2%`	`127/211`
`github.com/wfusion/gofusion/lock`	`80.9%`	`190/235`
`github.com/wfusion/gofusion/log`	`72.6%`	`162/223`
`github.com/wfusion/gofusion/log/customlogger`	`59.2%`	`287/485`
`github.com/wfusion/gofusion/log/encoder`	`100.0%`	`12/12`
`github.com/wfusion/gofusion/metrics`	`72.5%`	`190/262`
`github.com/wfusion/gofusion/mongo`	`76.6%`	`108/141`
`github.com/wfusion/gofusion/mq`	`62.1%`	`486/782`
`github.com/wfusion/gofusion/redis`	`23.4%`	`107/457`
`github.com/wfusion/gofusion/routine`	`48.4%`	`352/728`

This coverage report has been generated with the following command:

gocov test github.com/wfusion/gofusion/async github.com/wfusion/gofusion/cache github.com/wfusion/gofusion/common/constant github.com/wfusion/gofusion/common/di github.com/wfusion/gofusion/common/env github.com/wfusion/gofusion/common/infra/drivers/mongo github.com/wfusion/gofusion/common/infra/drivers/orm github.com/wfusion/gofusion/common/infra/drivers/orm/idgen github.com/wfusion/gofusion/common/infra/drivers/redis github.com/wfusion/gofusion/common/utils github.com/wfusion/gofusion/common/utils/cipher github.com/wfusion/gofusion/common/utils/clone github.com/wfusion/gofusion/common/utils/cmp github.com/wfusion/gofusion/common/utils/compress github.com/wfusion/gofusion/common/utils/encode github.com/wfusion/gofusion/common/utils/inspect github.com/wfusion/gofusion/common/utils/serialize github.com/wfusion/gofusion/config github.com/wfusion/gofusion/context github.com/wfusion/gofusion/cron github.com/wfusion/gofusion/db github.com/wfusion/gofusion/db/callbacks github.com/wfusion/gofusion/db/plugins github.com/wfusion/gofusion/db/softdelete github.com/wfusion/gofusion/http github.com/wfusion/gofusion/http/consts github.com/wfusion/gofusion/http/gracefully github.com/wfusion/gofusion/http/middleware github.com/wfusion/gofusion/http/parser github.com/wfusion/gofusion/i18n github.com/wfusion/gofusion/internal/configor github.com/wfusion/gofusion/internal/util/payload github.com/wfusion/gofusion/lock github.com/wfusion/gofusion/log github.com/wfusion/gofusion/log/customlogger github.com/wfusion/gofusion/log/encoder github.com/wfusion/gofusion/metrics github.com/wfusion/gofusion/mongo github.com/wfusion/gofusion/mq github.com/wfusion/gofusion/redis github.com/wfusion/gofusion/routine | gocov-html

Package Overview: github.com/wfusion/gofusion/async 68.8%

Please select a function to see what's left for testing.

`Construct(...)`	`github.com/wfusion/gofusion/async/construct.go`	`100.0%`	`7/7`
`asynqConsumer.shutdown(...)`	`github.com/wfusion/gofusion/async/asynq.go`	`100.0%`	`4/4`
`@212:27(...)`	`github.com/wfusion/gofusion/async/asynq.go`	`100.0%`	`3/3`
`asynqConsumer.adaptAsynqHandlerFunc(...)`	`github.com/wfusion/gofusion/async/asynq.go`	`100.0%`	`2/2`
`init(...)`	`github.com/wfusion/gofusion/async/construct.go`	`100.0%`	`1/1`
`asynqConsumer.unformatTaskName(...)`	`github.com/wfusion/gofusion/async/asynq.go`	`100.0%`	`1/1`
`@125:9(...)`	`github.com/wfusion/gofusion/async/types.go`	`100.0%`	`1/1`
`defaultQueue(...)`	`github.com/wfusion/gofusion/async/asynq.go`	`100.0%`	`1/1`
`Queue(...)`	`github.com/wfusion/gofusion/async/types.go`	`100.0%`	`1/1`
`asynqConsumer.gatewayMiddleware(...)`	`github.com/wfusion/gofusion/async/asynq.go`	`100.0%`	`1/1`
`asynqRedisConnOpt.MakeRedisClient(...)`	`github.com/wfusion/gofusion/async/asynq.go`	`100.0%`	`1/1`
`@122:9(...)`	`github.com/wfusion/gofusion/async/types.go`	`100.0%`	`1/1`
`Args(...)`	`github.com/wfusion/gofusion/async/types.go`	`100.0%`	`1/1`
`asynqConsumer.format(...)`	`github.com/wfusion/gofusion/async/log.go`	`100.0%`	`1/1`
`AppName(...)`	`github.com/wfusion/gofusion/async/construct.go`	`100.0%`	`1/1`
`formatTaskName(...)`	`github.com/wfusion/gofusion/async/asynq.go`	`100.0%`	`1/1`
`@127:9(...)`	`github.com/wfusion/gofusion/async/construct.go`	`100.0%`	`1/1`
`@34:9(...)`	`github.com/wfusion/gofusion/async/construct.go`	`92.3%`	`12/13`
`wrapParams(...)`	`github.com/wfusion/gofusion/async/utils.go`	`90.0%`	`9/10`
`unwrapParams(...)`	`github.com/wfusion/gofusion/async/utils.go`	`90.0%`	`9/10`
`newAsynqConsumer(...)`	`github.com/wfusion/gofusion/async/asynq.go`	`89.3%`	`25/28`
`asynqProducer.Go(...)`	`github.com/wfusion/gofusion/async/asynq.go`	`88.9%`	`16/18`
`asynqConsumer.info(...)`	`github.com/wfusion/gofusion/async/log.go`	`85.7%`	`6/7`
`asynqConsumer.Handle(...)`	`github.com/wfusion/gofusion/async/asynq.go`	`85.0%`	`17/20`
`asynqConsumer.Start(...)`	`github.com/wfusion/gofusion/async/asynq.go`	`83.3%`	`5/6`
`asynqProducer.Goc(...)`	`github.com/wfusion/gofusion/async/asynq.go`	`82.4%`	`14/17`
`addInstance(...)`	`github.com/wfusion/gofusion/async/construct.go`	`80.0%`	`24/30`
`P(...)`	`github.com/wfusion/gofusion/async/construct.go`	`80.0%`	`8/10`
`C(...)`	`github.com/wfusion/gofusion/async/construct.go`	`80.0%`	`8/10`
`@230:9(...)`	`github.com/wfusion/gofusion/async/asynq.go`	`80.0%`	`4/5`
`asynqProducer.newTask(...)`	`github.com/wfusion/gofusion/async/asynq.go`	`80.0%`	`4/5`
`asynqProducer.Send(...)`	`github.com/wfusion/gofusion/async/asynq.go`	`75.0%`	`6/8`
`asynqConsumer.HandleFunc(...)`	`github.com/wfusion/gofusion/async/asynq.go`	`66.7%`	`10/15`
`setParams(...)`	`github.com/wfusion/gofusion/async/utils.go`	`66.7%`	`8/12`
`newAsynqProducer(...)`	`github.com/wfusion/gofusion/async/asynq.go`	`66.7%`	`6/9`
`asynqProducer.parseOption(...)`	`github.com/wfusion/gofusion/async/asynq.go`	`60.0%`	`12/20`
`asynqConsumer.debug(...)`	`github.com/wfusion/gofusion/async/log.go`	`0.0%`	`0/7`
`asynqConsumer.warn(...)`	`github.com/wfusion/gofusion/async/log.go`	`0.0%`	`0/7`
`asynqConsumer.Serve(...)`	`github.com/wfusion/gofusion/async/asynq.go`	`0.0%`	`0/6`
`@81:40(...)`	`github.com/wfusion/gofusion/async/asynq.go`	`0.0%`	`0/4`
`asynqConsumer.Use(...)`	`github.com/wfusion/gofusion/async/asynq.go`	`0.0%`	`0/2`
`@220:9(...)`	`github.com/wfusion/gofusion/async/asynq.go`	`0.0%`	`0/2`
`asynqConsumer.adaptMiddleware(...)`	`github.com/wfusion/gofusion/async/asynq.go`	`0.0%`	`0/1`
`@222:28(...)`	`github.com/wfusion/gofusion/async/asynq.go`	`0.0%`	`0/1`
`task.ID(...)`	`github.com/wfusion/gofusion/async/types.go`	`0.0%`	`0/1`
`task.Name(...)`	`github.com/wfusion/gofusion/async/types.go`	`0.0%`	`0/1`
`task.Payload(...)`	`github.com/wfusion/gofusion/async/types.go`	`0.0%`	`0/1`
`task.RawMessage(...)`	`github.com/wfusion/gofusion/async/types.go`	`0.0%`	`0/1`
`TaskID(...)`	`github.com/wfusion/gofusion/async/types.go`	`0.0%`	`0/1`
`@119:9(...)`	`github.com/wfusion/gofusion/async/types.go`	`0.0%`	`0/1`
`@115:5(...)`	`github.com/wfusion/gofusion/async/construct.go`	`0.0%`	`0/1`
`asynqConsumer.adaptRouterHandlerFunc(...)`	`github.com/wfusion/gofusion/async/asynq.go`	`0.0%`	`0/1`
`Delay(...)`	`github.com/wfusion/gofusion/async/types.go`	`0.0%`	`0/1`
`@241:9(...)`	`github.com/wfusion/gofusion/async/asynq.go`	`0.0%`	`0/1`
`MaxRetry(...)`	`github.com/wfusion/gofusion/async/types.go`	`0.0%`	`0/1`
`@128:9(...)`	`github.com/wfusion/gofusion/async/types.go`	`0.0%`	`0/1`
`Deadline(...)`	`github.com/wfusion/gofusion/async/types.go`	`0.0%`	`0/1`
`@131:9(...)`	`github.com/wfusion/gofusion/async/types.go`	`0.0%`	`0/1`
`Timeout(...)`	`github.com/wfusion/gofusion/async/types.go`	`0.0%`	`0/1`
`@134:9(...)`	`github.com/wfusion/gofusion/async/types.go`	`0.0%`	`0/1`
`asynqConsumer.newTask(...)`	`github.com/wfusion/gofusion/async/asynq.go`	`0.0%`	`0/1`
`@137:9(...)`	`github.com/wfusion/gofusion/async/types.go`	`0.0%`	`0/1`
`DelayAt(...)`	`github.com/wfusion/gofusion/async/types.go`	`0.0%`	`0/1`
`@140:9(...)`	`github.com/wfusion/gofusion/async/types.go`	`0.0%`	`0/1`
`Retention(...)`	`github.com/wfusion/gofusion/async/types.go`	`0.0%`	`0/1`
`@143:9(...)`	`github.com/wfusion/gofusion/async/types.go`	`0.0%`	`0/1`
`@91:29(...)`	`github.com/wfusion/gofusion/async/asynq.go`	`0.0%`	`0/1`
`asynqConsumer.newAsynqTask(...)`	`github.com/wfusion/gofusion/async/asynq.go`	`0.0%`	`0/1`
`@94:5(...)`	`github.com/wfusion/gofusion/async/construct.go`	`0.0%`	`0/1`

func Construct

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/construct.go:

func Construct(ctx context.Context, confs map[string]*Conf, opts ...utils.OptionExtender) func() {
        opt := utils.ApplyOptions[config.InitOption](opts...)
        optU := utils.ApplyOptions[useOption](opts...)
        if opt.AppName == "" {
                opt.AppName = optU.appName
        }

        for name, conf := range confs {
                addInstance(ctx, name, conf, opt)
        }
        return func() {
                locker.Lock()
                defer locker.Unlock()

                pid := syscall.Getpid()
                app := config.Use(opt.AppName).AppName()
                if consumers != nil {
                        for name, router := range consumers[opt.AppName] {
                                log.Printf("%v [Gofusion] %s %s %s exiting...", pid, app, config.ComponentAsync, name)
                                if err := router.shutdown(); err == nil {
                                        log.Printf("%v [Gofusion] %s %s %s exited", pid, app, config.ComponentAsync, name)
                                } else {
                                        log.Printf("%v [Gofusion] %s %s %s exit failed: %s", pid, app, config.ComponentAsync, name, err)
                                }
                        }
                        delete(consumers, opt.AppName)
                }

                if producers != nil {
                        producers[opt.AppName] = make(map[string]Producable, len(producers))
                }
        }
}

func asynqConsumer.shutdown

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/asynq.go:

func (a *asynqConsumer) shutdown() (err error) {
        if a.consumer != nil {
                _, catchErr := utils.Catch(a.consumer.Shutdown)
                err = multierr.Append(err, errors.Cause(catchErr))
        }
        return
}

func @212:27

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/asynq.go:

func(ctx context.Context, raw *asynq.Task) (err error) {
                taskName := a.unformatTaskName(raw.Type())
                inspect.SetField(raw, asyncqTaskTypenameField, taskName)
                return next.ProcessTask(ctx, raw)
        }

func asynqConsumer.adaptAsynqHandlerFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/asynq.go:

func (a *asynqConsumer) adaptAsynqHandlerFunc(h any, typ reflect.Type, embed bool) asynq.HandlerFunc {
        fn := utils.WrapFunc1[error](h)
        return func(ctx context.Context, task *asynq.Task) (err error) {
                ctx, data, _, err := pd.Unseal(task.Payload(), pd.Type(typ))
                if err != nil {
                        return
                }
                params := unwrapParams(typ, embed, data)
                return fn(append([]any{ctx}, params...)...)
        }
}

func init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/construct.go:

164	`func init() {`
165	`config.AddComponent(config.ComponentAsync, Construct)`
166	`}`

func asynqConsumer.unformatTaskName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/asynq.go:

246	`func (a *asynqConsumer) unformatTaskName(taskName string) (result string) {`
247	`return strings.TrimPrefix(taskName, fmt.Sprintf("%s:async:", config.Use(a.appName).AppName()))`
248	`}`

func @125:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/types.go:

125	`func(o *produceOption) { o.queue = queue }`

func defaultQueue

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/asynq.go:

422	`func defaultQueue(appName string) (result string) {`
423	`return fmt.Sprintf("%s:async", config.Use(appName).AppName())`
424	`}`

func Queue

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/types.go:

124	`func Queue(queue string) utils.OptionFunc[produceOption] {`
125	`return func(o *produceOption) { o.queue = queue }`
126	`}`

func asynqConsumer.gatewayMiddleware

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/asynq.go:

func (a *asynqConsumer) gatewayMiddleware(next asynq.Handler) asynq.Handler {
        return asynq.HandlerFunc(func(ctx context.Context, raw *asynq.Task) (err error) {
                taskName := a.unformatTaskName(raw.Type())
                inspect.SetField(raw, asyncqTaskTypenameField, taskName)
                return next.ProcessTask(ctx, raw)
        })
}

func asynqRedisConnOpt.MakeRedisClient

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/asynq.go:

416	`func (a *asynqRedisConnOpt) MakeRedisClient() any { return a.UniversalClient }`

func @122:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/types.go:

122	`func(o *produceOption) { o.args = append(o.args, args...) }`

func Args

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/types.go:

121	`func Args(args ...any) utils.OptionFunc[produceOption] {`
122	`return func(o *produceOption) { o.args = append(o.args, args...) }`
123	`}`

func asynqConsumer.format

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/log.go:

48	`func (a *asynqConsumer) format(src string) (dst string) {`
49	`return fmt.Sprintf("%v [Gofusion] %s %s asynq %s",`
50	`syscall.Getpid(), config.ComponentAsync, a.n, src)`
51	`}`

func AppName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/construct.go:

func AppName(name string) utils.OptionFunc[useOption] {
        return func(o *useOption) {
                o.appName = name
        }
}

func formatTaskName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/asynq.go:

418	`func formatTaskName(appName, taskName string) (result string) {`
419	`return fmt.Sprintf("%s:async:%s", config.Use(appName).AppName(), taskName)`
420	`}`

func @127:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/construct.go:

127	`func(o *useOption) {`
128	`o.appName = name`
129	`}`

func @34:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/construct.go:

func() {
                locker.Lock()
                defer locker.Unlock()

                pid := syscall.Getpid()
                app := config.Use(opt.AppName).AppName()
                if consumers != nil {
                        for name, router := range consumers[opt.AppName] {
                                log.Printf("%v [Gofusion] %s %s %s exiting...", pid, app, config.ComponentAsync, name)
                                if err := router.shutdown(); err == nil {
                                        log.Printf("%v [Gofusion] %s %s %s exited", pid, app, config.ComponentAsync, name)
                                } else {
                                        log.Printf("%v [Gofusion] %s %s %s exit failed: %s", pid, app, config.ComponentAsync, name, err)
                                }
                        }
                        delete(consumers, opt.AppName)
                }

                if producers != nil {
                        producers[opt.AppName] = make(map[string]Producable, len(producers))
                }
        }

func wrapParams

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/utils.go:

func wrapParams(fn any) (argType reflect.Type, embed bool) {
        typ := reflect.TypeOf(fn)

        inLength := typ.NumIn()
        if inLength == 1 {
                return
        }
        if inLength == 2 {
                return typ.In(1), false
        }

        fields := make([]reflect.StructField, 0, inLength)
        for i := 1; i < inLength; i++ {
                fields = append(fields, reflect.StructField{
                        Name:      fmt.Sprintf("Arg%X", i+1),
                        PkgPath:   "",
                        Type:      typ.In(i),
                        Tag:       "",
                        Offset:    0,
                        Index:     nil,
                        Anonymous: false,
                })
        }

        return reflect.StructOf(fields), true
}

func unwrapParams

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/utils.go:

func unwrapParams(typ reflect.Type, embed bool, arg any) (params []any) {
        if typ == nil {
                return
        }

        if !embed {
                return []any{arg}
        }

        argVal := reflect.Indirect(reflect.ValueOf(arg))
        num := argVal.Type().NumField()
        params = make([]any, 0, num)
        for i := 0; i < num; i++ {
                params = append(params, argVal.Field(i).Interface())
        }

        return
}

func newAsynqConsumer

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/asynq.go:

func newAsynqConsumer(ctx context.Context, appName, name string, conf *Conf) Consumable {
        consumer := &asynqConsumer{appName: appName, n: name, c: conf}

        var rdsCli rdsDrv.UniversalClient
        switch conf.InstanceType {
        case instanceTypeRedis:
                rdsCli = redis.Use(ctx, conf.Instance, redis.AppName(appName))
        case instanceTypeDB:
                fallthrough
        default:
                panic(errors.Errorf("unknown instance type: %s", conf.InstanceType))
        }

        if consumer.logger == nil && utils.IsStrNotBlank(conf.Logger) {
                loggerType := inspect.TypeOf(conf.Logger)
                loggerValue := reflect.New(loggerType)
                if loggerValue.Type().Implements(customLoggerType) {
                        logger := log.Use(conf.LogInstance, log.AppName(appName))
                        loggerValue.Interface().(customLogger).Init(logger, appName, name)
                }
                consumer.logger = loggerValue.Convert(asynqLoggerType).Interface().(asynq.Logger)
        }

        logLevel := asynq.LogLevel(0)
        utils.MustSuccess(logLevel.Set(conf.LogLevel))

        consumer.ServeMux = asynq.NewServeMux()
        asynqCfg := asynq.Config{
                Concurrency:    conf.ConsumerConcurrency,
                BaseContext:    context.Background,
                RetryDelayFunc: asynq.DefaultRetryDelayFunc,
                IsFailure:      nil,
                Queues:         nil,
                StrictPriority: conf.StrictPriority,
                ErrorHandler: asynq.ErrorHandlerFunc(func(ctx context.Context, task *asynq.Task, err error) {
                        taskName := "unknown"
                        if task != nil {
                                taskName = consumer.unformatTaskName(task.Type())
                        }
                        consumer.info(ctx, "handle task %s message error %s", taskName, err)
                }),
                Logger:                   consumer.logger,
                LogLevel:                 logLevel,
                ShutdownTimeout:          8 * time.Second,
                HealthCheckFunc:          func(err error) { consumer.warn(ctx, "health check check failed: %s", err) },
                HealthCheckInterval:      15 * time.Second,
                DelayedTaskCheckInterval: 5 * time.Second,
                GroupGracePeriod:         1 * time.Minute,
                GroupMaxDelay:            0,
                GroupMaxSize:             0,
                GroupAggregator:          nil,
                DisableRedisConnClose:    true,
        }
        if len(conf.Queues) > 0 {
                asynqCfg.Queues = make(map[string]int, len(conf.Queues))
                for _, queue := range conf.Queues {
                        if _, ok := asynqCfg.Queues[queue.Name]; ok {
                                panic(ErrDuplicatedQueueName)
                        }
                        if utils.IsStrBlank(queue.Name) {
                                queue.Name = defaultQueue(appName)
                        }
                        asynqCfg.Queues[queue.Name] = queue.Level
                }
        } else {
                asynqCfg.Queues = map[string]int{defaultQueue(appName): 3}
        }

        consumer.consumer = asynq.NewServer(&asynqRedisConnOpt{UniversalClient: rdsCli}, asynqCfg)
        return consumer
}

func asynqProducer.Go

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/asynq.go:

func (a *asynqProducer) Go(fn any, opts ...utils.OptionExtender) (err error) {
        var data any
        opt := utils.ApplyOptions[produceOption](opts...)
        if len(opt.args) > 0 {
                argType, embed := wrapParams(fn)
                data = setParams(argType, embed, opt.args...)
        }

        // get task name by func name
        funcName := formatTaskName(a.appName, utils.GetFuncName(fn))
        callbackMapLock.RLock()
        if mappingName, ok := funcNameToTaskName[a.appName][funcName]; ok {
                funcName = mappingName
        }
        callbackMapLock.RUnlock()

        ctx := context.Background()
        task, err := a.newTask(ctx, funcName, data)
        if err != nil {
                return
        }

        _, err = a.Client.EnqueueContext(ctx, task, a.parseOption(opt)...)
        if err != nil {
                return
        }
        return
}

func asynqConsumer.info

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/log.go:

func (a *asynqConsumer) info(ctx context.Context, msg string, args ...any) {
        msg = a.format(msg)
        if a.logger == nil {
                log.Printf(msg, args...)
        } else {
                logArgs := make([]any, 0, len(args)+2)
                logArgs = append(logArgs, ctx, msg)
                logArgs = append(logArgs, args...)
                a.logger.Info(logArgs...)
        }
}

func asynqConsumer.Handle

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/asynq.go:

func (a *asynqConsumer) Handle(pattern string, fn any, _ ...utils.OptionExtender) {
        if !a.c.Consumer {
                a.debug(context.Background(), "cannot handle task: consumer is not enabled")
                return
        }
        name := formatTaskName(a.appName, pattern)
        funcName := formatTaskName(a.appName, utils.GetFuncName(fn))

        callbackMapLock.Lock()
        defer callbackMapLock.Unlock()
        if callbackMap[a.appName] == nil {
                callbackMap[a.appName] = make(map[string]any)
        }
        if funcNameToTaskName[a.appName] == nil {
                funcNameToTaskName[a.appName] = make(map[string]string)
        }
        if _, ok := callbackMap[a.appName][name]; ok {
                panic(ErrDuplicatedHandlerName)
        }
        callbackMap[a.appName][name] = fn
        callbackMap[a.appName][funcName] = fn
        funcNameToTaskName[a.appName][funcName] = name

        typ, embed := wrapParams(fn)
        a.ServeMux.Handle(name, a.adaptAsynqHandlerFunc(fn, typ, embed))
        if name != funcName {
                a.ServeMux.Handle(funcName, a.adaptAsynqHandlerFunc(fn, typ, embed))
        }
}

func asynqConsumer.Start

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/asynq.go:

func (a *asynqConsumer) Start() (err error) {
        if !a.c.Consumer {
                return ErrConsumerDisabled
        }

        defer a.info(context.Background(), "consumer started")

        a.ServeMux.Use(a.gatewayMiddleware)
        a.ServeMux.Use(a.mws...)

        return a.consumer.Start(a.ServeMux)
}

func asynqProducer.Goc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/asynq.go:

func (a *asynqProducer) Goc(ctx context.Context, fn any, opts ...utils.OptionExtender) (err error) {
        var data any
        opt := utils.ApplyOptions[produceOption](opts...)
        if len(opt.args) > 0 {
                argType, embed := wrapParams(fn)
                data = setParams(argType, embed, opt.args...)
        }

        // get task name by func name
        funcName := formatTaskName(a.appName, utils.GetFuncName(fn))
        callbackMapLock.RLock()
        if mappingName, ok := funcNameToTaskName[a.appName][funcName]; ok {
                funcName = mappingName
        }
        callbackMapLock.RUnlock()

        task, err := a.newTask(ctx, funcName, data)
        if err != nil {
                return
        }

        _, err = a.Client.EnqueueContext(ctx, task, a.parseOption(opt)...)
        if err != nil {
                return
        }
        return
}

func addInstance

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/construct.go:

func addInstance(ctx context.Context, name string, conf *Conf, opt *config.InitOption) {
        var (
                producer Producable
                consumer Consumable
        )
        switch conf.Type {
        case asyncTypeAsynq:
                if conf.Producer {
                        producer = newAsynqProducer(ctx, opt.AppName, name, conf)
                }
                if conf.Consumer {
                        consumer = newAsynqConsumer(ctx, opt.AppName, name, conf)
                }
        case asyncTypeMysql:
                fallthrough
        default:
                panic(ErrUnsupportedSchedulerType)
        }

        locker.Lock()
        defer locker.Unlock()
        if consumer != nil {
                if consumers == nil {
                        consumers = make(map[string]map[string]Consumable)
                }
                if consumers[opt.AppName] == nil {
                        consumers[opt.AppName] = make(map[string]Consumable)
                }
                if _, ok := consumers[name]; ok {
                        panic(ErrDuplicatedInstanceName)
                }
                consumers[opt.AppName][name] = consumer

                // ioc
                if opt.DI != nil {
                        opt.DI.MustProvide(
                                func() Consumable { return C(name, AppName(opt.AppName)) },
                                di.Name(name),
                        )
                }
        }

        if producer != nil {
                if producers == nil {
                        producers = make(map[string]map[string]Producable)
                }
                if producers[opt.AppName] == nil {
                        producers[opt.AppName] = make(map[string]Producable)
                }
                if _, ok := producers[name]; ok {
                        panic(ErrDuplicatedInstanceName)
                }
                producers[opt.AppName][name] = producer

                // ioc
                if opt.DI != nil {
                        opt.DI.MustProvide(
                                func() Producable { return P(name) },
                                di.Name(name),
                        )
                }
        }
}

func P

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/construct.go:

func P(name string, opts ...utils.OptionExtender) Producable {
        opt := utils.ApplyOptions[useOption](opts...)

        locker.RLock()
        defer locker.RUnlock()
        producers, ok := producers[opt.appName]
        if !ok {
                panic(errors.Errorf("async producer instance not found for app: %s", opt.appName))
        }
        producer, ok := producers[name]
        if !ok {
                panic(errors.Errorf("async producer instance not found for name: %s", name))
        }
        return producer
}

func C

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/construct.go:

func C(name string, opts ...utils.OptionExtender) Consumable {
        opt := utils.ApplyOptions[useOption](opts...)

        locker.RLock()
        defer locker.RUnlock()
        consumers, ok := consumers[opt.appName]
        if !ok {
                panic(errors.Errorf("async consumer instance not found for app: %s", opt.appName))
        }
        consumer, ok := consumers[name]
        if !ok {
                panic(errors.Errorf("async consumer instance not found for name: %s", name))
        }
        return consumer
}

func @230:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/asynq.go:

func(ctx context.Context, task *asynq.Task) (err error) {
                ctx, data, _, err := pd.Unseal(task.Payload(), pd.Type(typ))
                if err != nil {
                        return
                }
                params := unwrapParams(typ, embed, data)
                return fn(append([]any{ctx}, params...)...)
        }

func asynqProducer.newTask

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/asynq.go:

func (a *asynqProducer) newTask(ctx context.Context, taskName string, data any) (task *asynq.Task, err error) {
        payload, err := pd.Seal(data, pd.Context(ctx), pd.Serialize(a.serializeType), pd.Compress(a.compressType))
        if err != nil {
                return
        }

        task = asynq.NewTask(taskName, payload)
        return
}

func asynqProducer.Send

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/asynq.go:

func (a *asynqProducer) Send(ctx context.Context, taskName string, data any, opts ...utils.OptionExtender) (err error) {
        opt := utils.ApplyOptions[produceOption](opts...)
        task, err := a.newTask(ctx, formatTaskName(a.appName, taskName), data)
        if err != nil {
                return
        }

        _, err = a.Client.EnqueueContext(ctx, task, a.parseOption(opt)...)
        if err != nil {
                return
        }
        return
}

func asynqConsumer.HandleFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/asynq.go:

func (a *asynqConsumer) HandleFunc(fn any, _ ...utils.OptionExtender) {
        if !a.c.Consumer {
                a.debug(context.Background(), "cannot handle task: consumer is not enabled")
                return
        }
        funcName := formatTaskName(a.appName, utils.GetFuncName(fn))

        callbackMapLock.Lock()
        defer callbackMapLock.Unlock()
        if callbackMap[a.appName] == nil {
                callbackMap[a.appName] = make(map[string]any)
        }
        if funcNameToTaskName[a.appName] == nil {
                funcNameToTaskName[a.appName] = make(map[string]string)
        }
        if _, ok := callbackMap[funcName]; ok {
                panic(ErrDuplicatedHandlerName)
        }
        callbackMap[a.appName][funcName] = fn

        typ, embed := wrapParams(fn)
        a.ServeMux.Handle(funcName, a.adaptAsynqHandlerFunc(fn, typ, embed))
}

func setParams

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/utils.go:

func setParams(typ reflect.Type, embed bool, params ...any) (arg any) {
        if typ == nil {
                return
        }

        argValPtr := reflect.New(typ)
        argVal := argValPtr.Elem()
        if !embed {
                if len(params) > 0 {
                        argVal.Set(reflect.ValueOf(params[0]))
                }
                return argValPtr.Interface()
        }

        for i := 0; i < len(params); i++ {
                ft := argVal.Field(i)
                ft.Set(reflect.ValueOf(params[i]).Convert(ft.Type()))
        }
        return argValPtr.Interface()
}

func newAsynqProducer

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/asynq.go:

func newAsynqProducer(ctx context.Context, appName, name string, conf *Conf) Producable {
        var rdsCli rdsDrv.UniversalClient
        switch conf.InstanceType {
        case instanceTypeRedis:
                rdsCli = redis.Use(ctx, conf.Instance, redis.AppName(appName))
        case instanceTypeDB:
                fallthrough
        default:
                panic(errors.Errorf("unknown instance type: %s", conf.InstanceType))
        }

        producer := &asynqProducer{
                appName:       appName,
                n:             name,
                c:             conf,
                Client:        asynq.NewClient(&asynqRedisConnOpt{UniversalClient: rdsCli}),
                compressType:  compress.ParseAlgorithm(conf.MessageCompressType),
                serializeType: serialize.ParseAlgorithm(conf.MessageSerializeType),
        }
        // default serialize type
        if !producer.serializeType.IsValid() {
                producer.serializeType = serialize.AlgorithmGob
        }
        return producer
}

func asynqProducer.parseOption

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/asynq.go:

func (a *asynqProducer) parseOption(src *produceOption) (dst []asynq.Option) {
        if utils.IsStrNotBlank(src.id) {
                dst = append(dst, asynq.TaskID(src.id))
        }
        if utils.IsStrNotBlank(src.queue) {
                dst = append(dst, asynq.Queue(src.queue))
        } else if len(a.c.Queues) == 1 {
                dst = append(dst, asynq.Queue(a.c.Queues[0].Name))
        } else {
                dst = append(dst, asynq.Queue(defaultQueue(a.appName)))
        }
        if src.maxRetry > 0 {
                dst = append(dst, asynq.MaxRetry(src.maxRetry))
        }
        if !src.deadline.IsZero() {
                dst = append(dst, asynq.Deadline(src.deadline))
        }
        if src.timeout > 0 {
                dst = append(dst, asynq.Timeout(src.timeout))
        }
        if src.delayDuration > 0 {
                dst = append(dst, asynq.ProcessIn(src.timeout))
        }
        if !src.delayTime.IsZero() {
                dst = append(dst, asynq.ProcessAt(src.delayTime))
        }
        if src.retentionDuration > 0 {
                dst = append(dst, asynq.Retention(src.retentionDuration))
        }

        return
}

func asynqConsumer.debug

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/log.go:

func (a *asynqConsumer) debug(ctx context.Context, msg string, args ...any) {
        msg = a.format(msg)
        if a.logger == nil {
                log.Printf(msg, args...)
        } else {
                logArgs := make([]any, 0, len(args)+2)
                logArgs = append(logArgs, ctx, msg)
                logArgs = append(logArgs, args...)
                a.logger.Debug(logArgs...)
        }
}

func asynqConsumer.warn

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/log.go:

func (a *asynqConsumer) warn(ctx context.Context, msg string, args ...any) {
        msg = a.format(msg)
        if a.logger == nil {
                log.Printf(msg, args...)
        } else {
                logArgs := make([]any, 0, len(args)+2)
                logArgs = append(logArgs, ctx, msg)
                logArgs = append(logArgs, args...)
                a.logger.Warn(logArgs...)
        }
}

func asynqConsumer.Serve

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/asynq.go:

func (a *asynqConsumer) Serve() (err error) {
        if !a.c.Consumer {
                return ErrConsumerDisabled
        }
        defer a.info(context.Background(), "consumer started")

        a.ServeMux.Use(a.gatewayMiddleware)
        a.ServeMux.Use(a.mws...)
        return a.consumer.Run(a.ServeMux)
}

func @81:40

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/asynq.go:

func(ctx context.Context, task *asynq.Task, err error) {
                        taskName := "unknown"
                        if task != nil {
                                taskName = consumer.unformatTaskName(task.Type())
                        }
                        consumer.info(ctx, "handle task %s message error %s", taskName, err)
                }

func asynqConsumer.Use

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/asynq.go:

func (a *asynqConsumer) Use(mws ...routerMiddleware) {
        for _, mw := range mws {
                a.mws = append(a.mws, a.adaptMiddleware(mw))
        }
}

func @220:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/asynq.go:

func(asynqNext asynq.Handler) asynq.Handler {
                next := mw(a.adaptRouterHandlerFunc(asynqNext))
                return asynq.HandlerFunc(func(ctx context.Context, t *asynq.Task) error {
                        return next(ctx, a.newTask(t))
                })
        }

func asynqConsumer.adaptMiddleware

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/asynq.go:

func (a *asynqConsumer) adaptMiddleware(mw routerMiddleware) asynq.MiddlewareFunc {
        return func(asynqNext asynq.Handler) asynq.Handler {
                next := mw(a.adaptRouterHandlerFunc(asynqNext))
                return asynq.HandlerFunc(func(ctx context.Context, t *asynq.Task) error {
                        return next(ctx, a.newTask(t))
                })
        }
}

func @222:28

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/asynq.go:

222	`func(ctx context.Context, t *asynq.Task) error {`
223	`return next(ctx, a.newTask(t))`
224	`}`

func task.ID

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/types.go:

90	`func (t *task) ID() string {`
91	`return t.id`
92	`}`

func task.Name

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/types.go:

94	`func (t *task) Name() string {`
95	`return t.name`
96	`}`

func task.Payload

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/types.go:

98	`func (t *task) Payload() []byte {`
99	`return t.payload`
100	`}`

func task.RawMessage

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/types.go:

102	`func (t *task) RawMessage() any {`
103	`return t.rawMessage`
104	`}`

func TaskID

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/types.go:

118	`func TaskID(id string) utils.OptionFunc[produceOption] {`
119	`return func(o *produceOption) { o.id = id }`
120	`}`

func @119:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/types.go:

119	`func(o *produceOption) { o.id = id }`

func @115:5

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/construct.go:

115	`func() Producable { return P(name) }`

func asynqConsumer.adaptRouterHandlerFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/asynq.go:

func (a *asynqConsumer) adaptRouterHandlerFunc(h asynq.Handler) routerMiddlewareFunc {
        return func(ctx context.Context, raw Task) (err error) {
                return h.ProcessTask(ctx, a.newAsynqTask(raw))
        }
}

func Delay

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/types.go:

136	`func Delay(d time.Duration) utils.OptionFunc[produceOption] {`
137	`return func(o *produceOption) { o.delayDuration = d }`
138	`}`

func @241:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/asynq.go:

241	`func(ctx context.Context, raw Task) (err error) {`
242	`return h.ProcessTask(ctx, a.newAsynqTask(raw))`
243	`}`

func MaxRetry

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/types.go:

127	`func MaxRetry(n int) utils.OptionFunc[produceOption] {`
128	`return func(o *produceOption) { o.maxRetry = n }`
129	`}`

func @128:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/types.go:

128	`func(o *produceOption) { o.maxRetry = n }`

func Deadline

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/types.go:

130	`func Deadline(t time.Time) utils.OptionFunc[produceOption] {`
131	`return func(o *produceOption) { o.deadline = t }`
132	`}`

func @131:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/types.go:

131	`func(o *produceOption) { o.deadline = t }`

func Timeout

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/types.go:

133	`func Timeout(d time.Duration) utils.OptionFunc[produceOption] {`
134	`return func(o *produceOption) { o.timeout = d }`
135	`}`

func @134:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/types.go:

134	`func(o *produceOption) { o.timeout = d }`

func asynqConsumer.newTask

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/asynq.go:

func (a *asynqConsumer) newTask(raw *asynq.Task) (t Task) {
        return &task{
                id:         raw.Type(),
                name:       raw.Type(),
                payload:    raw.Payload(),
                rawMessage: raw,
        }
}

func @137:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/types.go:

137	`func(o *produceOption) { o.delayDuration = d }`

func DelayAt

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/types.go:

139	`func DelayAt(t time.Time) utils.OptionFunc[produceOption] {`
140	`return func(o *produceOption) { o.delayTime = t }`
141	`}`

func @140:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/types.go:

140	`func(o *produceOption) { o.delayTime = t }`

func Retention

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/types.go:

142	`func Retention(d time.Duration) utils.OptionFunc[produceOption] {`
143	`return func(o *produceOption) { o.retentionDuration = d }`
144	`}`

func @143:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/types.go:

143	`func(o *produceOption) { o.retentionDuration = d }`

func @91:29

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/asynq.go:

91	`func(err error) { consumer.warn(ctx, "health check check failed: %s", err) }`

func asynqConsumer.newAsynqTask

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/asynq.go:

259	`func (a asynqConsumer) newAsynqTask(raw Task) (t asynq.Task) {`
260	`return raw.RawMessage().(*asynq.Task)`
261	`}`

func @94:5

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/async/construct.go:

94	`func() Consumable { return C(name, AppName(opt.AppName)) }`

Package Overview: github.com/wfusion/gofusion/cache 76.9%

Please select a function to see what's left for testing.

`.parseCallbackOption(...)`	`github.com/wfusion/gofusion/cache/cache.go`	`100.0%`	`13/13`
`.convValToInner(...)`	`github.com/wfusion/gofusion/cache/cache.go`	`100.0%`	`3/3`
`Construct(...)`	`github.com/wfusion/gofusion/cache/construct.go`	`100.0%`	`3/3`
`@192:8(...)`	`github.com/wfusion/gofusion/cache/cache.go`	`100.0%`	`2/2`
`.unseal(...)`	`github.com/wfusion/gofusion/cache/cache.go`	`100.0%`	`2/2`
`.convInnerToKey(...)`	`github.com/wfusion/gofusion/cache/cache.go`	`100.0%`	`2/2`
`.convKeysToInner(...)`	`github.com/wfusion/gofusion/cache/cache.go`	`100.0%`	`1/1`
`init(...)`	`github.com/wfusion/gofusion/cache/construct.go`	`100.0%`	`1/1`
`newRedis(...)`	`github.com/wfusion/gofusion/cache/redis.go`	`100.0%`	`1/1`
`Expired(...)`	`github.com/wfusion/gofusion/cache/types.go`	`100.0%`	`1/1`
`@237:34(...)`	`github.com/wfusion/gofusion/cache/cache.go`	`100.0%`	`1/1`
`.convKeyToInner(...)`	`github.com/wfusion/gofusion/cache/cache.go`	`100.0%`	`1/1`
`.convInnerToKeys(...)`	`github.com/wfusion/gofusion/cache/cache.go`	`100.0%`	`1/1`
`@247:39(...)`	`github.com/wfusion/gofusion/cache/cache.go`	`100.0%`	`1/1`
`@39:9(...)`	`github.com/wfusion/gofusion/cache/types.go`	`100.0%`	`1/1`
`KeyExpired(...)`	`github.com/wfusion/gofusion/cache/types.go`	`100.0%`	`1/1`
`@52:9(...)`	`github.com/wfusion/gofusion/cache/cache.go`	`100.0%`	`1/1`
`.seal(...)`	`github.com/wfusion/gofusion/cache/cache.go`	`100.0%`	`1/1`
`AppName(...)`	`github.com/wfusion/gofusion/cache/cache.go`	`100.0%`	`1/1`
`@45:9(...)`	`github.com/wfusion/gofusion/cache/types.go`	`100.0%`	`1/1`
`gCache.get(...)`	`github.com/wfusion/gofusion/cache/local.go`	`90.9%`	`10/11`
`.Get(...)`	`github.com/wfusion/gofusion/cache/cache.go`	`88.5%`	`23/26`
`.convInnerToVal(...)`	`github.com/wfusion/gofusion/cache/cache.go`	`86.7%`	`13/15`
`.Del(...)`	`github.com/wfusion/gofusion/cache/cache.go`	`85.7%`	`6/7`
`.Set(...)`	`github.com/wfusion/gofusion/cache/cache.go`	`85.7%`	`6/7`
`.Clear(...)`	`github.com/wfusion/gofusion/cache/cache.go`	`85.7%`	`6/7`
`.getConfig(...)`	`github.com/wfusion/gofusion/cache/cache.go`	`84.6%`	`22/26`
`rds.set(...)`	`github.com/wfusion/gofusion/cache/redis.go`	`76.9%`	`10/13`
`rds.get(...)`	`github.com/wfusion/gofusion/cache/redis.go`	`69.2%`	`9/13`
`New(...)`	`github.com/wfusion/gofusion/cache/cache.go`	`69.2%`	`9/13`
`rds.del(...)`	`github.com/wfusion/gofusion/cache/redis.go`	`66.7%`	`14/21`
`gCache.del(...)`	`github.com/wfusion/gofusion/cache/local.go`	`66.7%`	`6/9`
`.convInnerToMap(...)`	`github.com/wfusion/gofusion/cache/cache.go`	`63.6%`	`7/11`
`gCache.set(...)`	`github.com/wfusion/gofusion/cache/local.go`	`63.6%`	`7/11`
`.convMapToInner(...)`	`github.com/wfusion/gofusion/cache/cache.go`	`63.6%`	`7/11`
`.GetAll(...)`	`github.com/wfusion/gofusion/cache/cache.go`	`63.0%`	`17/27`
`addInstance(...)`	`github.com/wfusion/gofusion/cache/construct.go`	`54.5%`	`6/11`
`newGCache(...)`	`github.com/wfusion/gofusion/cache/local.go`	`50.0%`	`4/8`
`.cloneVal(...)`	`github.com/wfusion/gofusion/cache/cache.go`	`50.0%`	`2/4`
`@21:9(...)`	`github.com/wfusion/gofusion/cache/construct.go`	`100.0%`	`0/0`

func .parseCallbackOption

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/cache.go:

func (c *cache[K, T, TS]) parseCallbackOption(kvs map[K]T, conf *parsedConf[K, T], opts ...utils.OptionExtender) (
        exp map[string]time.Duration) {
        opt := utils.ApplyOptions[option[K]](opts...)
        exp = make(map[string]time.Duration, len(kvs))

        // opt.keyExpired > opt.expired > conf.expired
        if conf.expired > 0 {
                for k := range kvs {
                        innerKey := c.convKeyToInner(k, conf.version)
                        exp[innerKey] = conf.expired
                }
        }

        if opt.expired > 0 {
                for k := range kvs {
                        innerKey := c.convKeyToInner(k, conf.version)
                        exp[innerKey] = conf.expired
                }
        }

        for k, e := range opt.keyExpired {
                exp[c.convKeyToInner(k, conf.version)] = e
        }

        return
}

func .convValToInner

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/cache.go:

func (c *cache[K, T, TS]) convValToInner(src T, conf *parsedConf[K, T]) (dst any, err error) {
        if !conf.serializeType.IsValid() && !conf.compressType.IsValid() {
                return c.cloneVal(src), nil
        }

        return c.seal(src, conf)
}

func Construct

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/construct.go:

func Construct(ctx context.Context, confs map[string]*Conf, _ ...utils.OptionExtender) func() {
        for _, conf := range confs {
                addInstance(ctx, conf)
        }

        return func() {

        }
}

func @192:8

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/cache.go:

192	`func() {`
193	`innerKeys := utils.MapKeys(innerVals)`
194	`c.visited.Insert(innerKeys...)`
195	`}`

func .unseal

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/cache.go:

356	`func (c *cache[K, T, TS]) unseal(src []byte) (dst T, ok bool, err error) {`
357	`_, dst, ok, err = pd.UnsealT[T](src)`
358	`return`
359	`}`

func .convInnerToKey

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/cache.go:

252	`func (c *cache[K, T, TS]) convInnerToKey(inner string, ver int) (k K) {`
253	`key := strings.TrimPrefix(inner, fmt.Sprintf("%s:%v:", c.prefix, ver))`
254	`return utils.SortableToGeneric[string, K](key)`
255	`}`

func .convKeysToInner

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/cache.go:

func (c *cache[K, T, TS]) convKeysToInner(keys []K, version int) (inner []string) {
        return utils.SliceMapping(keys, func(k K) string {
                return c.convKeyToInner(k, version)
        })
}

func init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/construct.go:

51	`func init() {`
52	`config.AddComponent(config.ComponentCache, Construct)`
53	`}`

func newRedis

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/redis.go:

func newRedis(appName, name string, log log.Loggable) provider {
        return &rds{
                appName:  appName,
                name:     name,
                log:      log,
                instance: redis.Use(context.Background(), name, redis.AppName(appName)),
        }
}

func Expired

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/types.go:

func Expired[K constraint.Sortable](expired time.Duration) utils.OptionFunc[option[K]] {
        return func(o *option[K]) {
                o.expired = expired
        }
}

func @237:34

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/cache.go:

237	`func(k K) string {`
238	`return c.convKeyToInner(k, version)`
239	`}`

func .convKeyToInner

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/cache.go:

242	`func (c *cache[K, T, TS]) convKeyToInner(k K, ver int) (inner string) {`
243	`return fmt.Sprintf("%s:%v:%s", c.prefix, ver, cast.ToString(k))`
244	`}`

func .convInnerToKeys

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/cache.go:

func (c *cache[K, T, TS]) convInnerToKeys(innerKeys []string, ver int) (keys []K) {
        return utils.SliceMapping(innerKeys, func(inner string) K {
                return c.convInnerToKey(inner, ver)
        })
}

func @247:39

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/cache.go:

247	`func(inner string) K {`
248	`return c.convInnerToKey(inner, ver)`
249	`}`

func @39:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/types.go:

39	`func(o *option[K]) {`
40	`o.expired = expired`
41	`}`

func KeyExpired

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/types.go:

func KeyExpired[K constraint.Sortable](keyExpired map[K]time.Duration) utils.OptionFunc[option[K]] {
        return func(o *option[K]) {
                o.keyExpired = keyExpired
        }
}

func @52:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/cache.go:

52	`func(o *initOption) {`
53	`o.appName = name`
54	`}`

func .seal

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/cache.go:

352	`func (c cache[K, T, TS]) seal(src T, conf parsedConf[K, T]) (dst []byte, err error) {`
353	`return pd.Seal(src, pd.Serialize(conf.serializeType), pd.Compress(conf.compressType))`
354	`}`

func AppName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/cache.go:

func AppName(name string) utils.OptionFunc[initOption] {
        return func(o *initOption) {
                o.appName = name
        }
}

func @45:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/types.go:

45	`func(o *option[K]) {`
46	`o.keyExpired = keyExpired`
47	`}`

func gCache.get

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/local.go:

func (g *gCache) get(ctx context.Context, keys ...string) (cached map[string]any, missed []string) {
        cached = make(map[string]any, len(keys))
        missed = make([]string, 0, len(keys))
        for _, k := range keys {
                v, err := g.instance.Get(k)
                if err != nil {
                        missed = append(missed, k)
                        if !errors.Is(err, gcache.KeyNotFoundError) && g.log != nil {
                                g.log.Info(ctx, "%v [Gofusion] %s call gcache get failed "+
                                        "when get cache from gcache [err[%s] key[%s]]", syscall.Getpid(), config.ComponentCache, err, k)
                        }
                        continue
                }
                cached[k] = v
        }
        return
}

func .Get

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/cache.go:

func (c *cache[K, T, TS]) Get(ctx context.Context, keys []K, cb callback[K, T]) (ts TS) {
        conf := c.getConfig()
        innerKeys := c.convKeysToInner(keys, conf.version)
        cached, missed := c.provider.get(ctx, innerKeys...)
        kvs, _ := c.convInnerToMap(ctx, cached, conf)
        defer c.visited.Insert(innerKeys...)

        if cb == nil {
                cb = conf.callback
        }
        if len(missed) > 0 && cb != nil {
                keys := c.convInnerToKeys(missed, conf.version)
                if conf.log != nil {
                        conf.log.Debug(ctx, "%v [Gofusion] %s call callback function because we do not hit the cache "+
                                "when get [keys%+v]", syscall.Getpid(), config.ComponentCache, keys)
                }

                callbackKVs, opts := cb(ctx, keys)
                kvs = utils.MapMerge(kvs, callbackKVs)
                innerVals, _ := c.convMapToInner(ctx, callbackKVs, conf)
                _ = c.provider.set(ctx, innerVals, c.parseCallbackOption(kvs, conf, opts...))
                // innerFailureKeys = append(innerFailureKeys, convInnerFailureKeys...)
        }

        // order by param -> keys
        ts = make(TS, 0, len(kvs))
        missedKeys := make([]K, 0, len(keys))
        for _, k := range keys {
                v, ok := kvs[k]
                if !ok {
                        missedKeys = append(missedKeys, k)
                        continue
                }

                ts = append(ts, v)
        }
        if len(missedKeys) > 0 && conf.log != nil {
                conf.log.Info(ctx, "%v [Gofusion] %s we still get missing keys after callback when cache get [keys%v]",
                        syscall.Getpid(), config.ComponentCache, missedKeys)
        }

        return
}

func .convInnerToVal

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/cache.go:

func (c *cache[K, T, TS]) convInnerToVal(src any) (dst T, err error) {
        srcBytes, ok1 := src.([]byte)
        srcString, ok2 := src.(string)
        if !ok1 && !ok2 {
                return c.cloneVal(src.(T)), nil
        }
        if ok2 {
                buffer, cb := utils.BytesBufferPool.Get(nil)
                defer cb()
                buffer.WriteString(srcString)
                srcBytes = buffer.Bytes()
        }
        dst, ok, err := c.unseal(srcBytes)
        if err != nil {
                return
        }
        if !ok {
                return c.cloneVal(src.(T)), nil
        }
        return
}

func .Del

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/cache.go:

func (c *cache[K, T, TS]) Del(ctx context.Context, keys ...K) (failure []K) {
        conf := c.getConfig()
        innerKeys := c.convKeysToInner(keys, conf.version)
        innerFailureKeys := c.provider.del(ctx, innerKeys...)
        defer c.visited.Remove(innerKeys...)

        if failure = c.convInnerToKeys(innerFailureKeys, conf.version); len(failure) > 0 && conf.log != nil {
                conf.log.Info(ctx, "%v [Gofusion] %s del some kvs failed when del [keys%+v]",
                        syscall.Getpid(), config.ComponentCache, failure)
        }
        return
}

func .Set

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/cache.go:

func (c *cache[K, T, TS]) Set(ctx context.Context, kvs map[K]T, opts ...utils.OptionExtender) (failure []K) {
        conf := c.getConfig()
        innerVals, innerFailureKeys := c.convMapToInner(ctx, kvs, conf)
        defer func() {
                innerKeys := utils.MapKeys(innerVals)
                c.visited.Insert(innerKeys...)
        }()

        innerFailureKeys = append(
                innerFailureKeys,
                c.provider.set(ctx, innerVals, c.parseCallbackOption(kvs, conf, opts...))...,
        )

        if failure = c.convInnerToKeys(innerFailureKeys, conf.version); len(failure) > 0 && conf.log != nil {
                conf.log.Info(ctx, "%v [Gofusion] %s set some kvs failed when set [keys%+v vals%+v]",
                        syscall.Getpid(), config.ComponentCache, failure, utils.MapValuesByKeys(kvs, failure))
        }

        return
}

func .Clear

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/cache.go:

func (c *cache[K, T, TS]) Clear(ctx context.Context) (failureKeys []K) {
        conf := c.getConfig()
        innerKeys := c.visited.Items()
        innerFailureKeys := c.provider.del(ctx, innerKeys...)
        defer c.visited.Remove(innerKeys...)

        if failureKeys = c.convInnerToKeys(innerFailureKeys, conf.version); len(failureKeys) > 0 && conf.log != nil {
                conf.log.Info(ctx, "%v [Gofusion] %s del some kvs failed when clear [keys%+v]",
                        syscall.Getpid(), config.ComponentCache, failureKeys)
        }
        return
}

func .getConfig

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/cache.go:

func (c *cache[K, T, TS]) getConfig() (conf *parsedConf[K, T]) {
        var cfgs map[string]*Conf
        _ = config.Use(c.appName).LoadComponentConfig(config.ComponentCache, &cfgs)
        if len(cfgs) == 0 {
                panic(ErrCacheNotFound)
        }

        cfg, ok := cfgs[c.name]
        if !ok {
                panic(ErrCacheNotFound)
        }

        conf = &parsedConf[K, T]{
                size:           cfg.Size,
                localEvictType: cfg.LocalEvictType,
                cacheType:      cfg.CacheType,
                remoteType:     cfg.RemoteType,
                remoteInstance: cfg.RemoteInstance,
                version:        cfg.Version,
        }
        if utils.IsStrNotBlank(cfg.Expired) {
                conf.expired = utils.Must(time.ParseDuration(cfg.Expired))
        }
        if utils.IsStrNotBlank(cfg.LogInstance) {
                conf.log = log.Use(cfg.LogInstance, log.AppName(c.appName))
        }

        if utils.IsStrNotBlank(cfg.SerializeType) {
                conf.serializeType = serialize.ParseAlgorithm(cfg.SerializeType)
        }

        if utils.IsStrNotBlank(cfg.Compress) {
                conf.compressType = compress.ParseAlgorithm(cfg.Compress)
                if !conf.compressType.IsValid() {
                        panic(UnknownCompress)
                }
        }
        // default serialize type when need compress
        if conf.compressType.IsValid() && !conf.serializeType.IsValid() {
                conf.serializeType = serialize.AlgorithmGob
        }

        if utils.IsStrNotBlank(cfg.Callback) {
                callbackFn := inspect.FuncOf(cfg.Callback)
                if callbackFn == nil {
                        panic(errors.Errorf("not found callback function: %s", cfg.Callback))
                }
                conf.callback = *(*func(ctx context.Context, missed []K) (rs map[K]T, opts []utils.OptionExtender))(callbackFn)
        }

        return
}

func rds.set

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/redis.go:

func (r *rds) set(ctx context.Context, kvs map[string]any, expired map[string]time.Duration) (failure []string) {
        failure = make([]string, 0, len(kvs))
        pipe := r.instance.Pipeline()
        keys := make([]string, 0, len(kvs))
        for k, v := range kvs {
                keys = append(keys, k)
                pipe.Set(ctx, k, v, expired[k])
        }

        cmds := utils.Must(pipe.Exec(ctx))
        for i := 0; i < len(keys); i++ {
                if err := cmds[i].Err(); err != nil {
                        failure = append(failure, keys[i])
                        if r.log != nil {
                                r.log.Info(ctx, "%v [Gofusion] %s call redis set failed when set cache into redis "+
                                        "[err[%s] redis[%s] key[%s]]", syscall.Getpid(), config.ComponentCache, err, r.name, keys[i])
                        }
                }
        }
        return
}

func rds.get

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/redis.go:

func (r *rds) get(ctx context.Context, keys ...string) (cached map[string]any, missed []string) {
        cached = make(map[string]any, len(keys))
        missed = make([]string, 0, len(keys))

        rs, err := r.instance.MGet(ctx, keys...).Result()
        if err != nil {
                missed = keys
                if r.log != nil {
                        r.log.Info(ctx, "%v [Gofusion] %s call redis mget failed when get cache from redis "+
                                "[err[%s] redis[%s]]", syscall.Getpid(), config.ComponentCache, err, r.name)
                }
                return
        }
        for i := 0; i < len(keys); i++ {
                if rs[i] != nil {
                        cached[keys[i]] = rs[i]
                } else {
                        missed = append(missed, keys[i])
                }
        }

        return
}

func New

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/cache.go:

func New[K constraint.Sortable, T any, TS ~[]T](name string, opts ...utils.OptionExtender) Cachable[K, T, TS] {
        opt := utils.ApplyOptions[initOption](opts...)

        instance := &cache[K, T, TS]{
                name:    name,
                appName: opt.appName,
                prefix:  fmt.Sprintf("%s:%s", config.Use(opt.appName).AppName(), name),
                visited: utils.NewSet[string](),
        }

        conf := instance.getConfig()
        switch conf.cacheType {
        case cacheTypeLocal:
                instance.provider = newGCache(conf.size, conf.localEvictType, conf.log)
        case cacheTypeRemote:
                if conf.remoteType != remoteTypeRedis {
                        panic(UnknownRemoteType)
                }
                if !conf.serializeType.IsValid() && !conf.compressType.IsValid() {
                        panic(UnknownSerializeType)
                }
                instance.provider = newRedis(opt.appName, conf.remoteInstance, conf.log)
        case cacheTypeRemoteLocal:
                panic(ErrNotImplement)
        default:
                panic(UnknownCacheType)
        }

        return instance
}

func rds.del

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/redis.go:

func (r *rds) del(ctx context.Context, keys ...string) (failure []string) {
        affected, err := r.instance.Del(ctx, keys...).Result()
        if err != nil && r.log != nil {
                r.log.Info(ctx, "%v [Gofusion] %s call redis del failed when delete from cache "+
                        "[err[%s] redis[%s] keys%v]", syscall.Getpid(), config.ComponentCache, err, r.name, keys)
        }

        if affected == int64(len(keys)) {
                return
        }

        failure = make([]string, 0, len(keys))
        pipe := r.instance.Pipeline()
        for i := 0; i < len(keys); i++ {
                pipe.Exists(ctx, keys[i])
        }
        cmds, err := pipe.Exec(ctx)
        if err != nil && r.log != nil {
                r.log.Info(ctx, "%v [Gofusion] %s call redis exists failed when delete from cache "+
                        "[err[%s] redis[%s] keys%v]", syscall.Getpid(), config.ComponentCache, err, r.name, keys)
                return keys // we cannot know whether ths keys are deleted
        }

        for i := 0; i < len(keys); i++ {
                if err := cmds[i].Err(); err != nil {
                        failure = append(failure, keys[i]) // we cannot know whether ths key is deleted
                        r.log.Info(ctx, "%v [Gofusion] %s call redis exists failed when delete from cache "+
                                "[err[%s] redis[%s] key[%s]]", syscall.Getpid(), config.ComponentCache, err, r.name, keys[i])
                        continue
                }

                if cmds[i].String() == "1" {
                        failure = append(failure, keys[i])
                }
        }

        return
}

func gCache.del

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/local.go:

func (g *gCache) del(ctx context.Context, keys ...string) (failure []string) {
        failure = make([]string, 0, len(keys))
        for _, k := range keys {
                if g.instance.Remove(k) {
                        continue
                }

                if _, err := g.instance.Get(k); !errors.Is(err, gcache.KeyNotFoundError) {
                        failure = append(failure, k)
                        if g.log != nil {
                                g.log.Info(ctx, "%v [Gofusion] %s call gcache remove failed "+
                                        "when delete cache from gcache [err[%s] key[%s]]", syscall.Getpid(), config.ComponentCache, err, k)
                        }
                }
        }
        return
}

func .convInnerToMap

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/cache.go:

func (c *cache[K, T, TS]) convInnerToMap(ctx context.Context, inner map[string]any, conf *parsedConf[K, T]) (
        kvs map[K]T, innerFailureKeys []string) {
        kvs = make(map[K]T, len(inner))
        for k, v := range inner {
                innerKey := c.convInnerToKey(k, conf.version)
                innerVal, err := c.convInnerToVal(v)
                if err != nil {
                        if conf.log != nil {
                                conf.log.Info(ctx, "%v [Gofusion] %s convert inner to value failed [err[%s] key[%+v] val[%+v]]",
                                        syscall.Getpid(), config.ComponentCache, err, innerKey, v)
                        }
                        innerFailureKeys = append(innerFailureKeys, k)
                        continue
                }
                kvs[innerKey] = innerVal
        }
        return
}

func gCache.set

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/local.go:

func (g *gCache) set(ctx context.Context, kvs map[string]any, expired map[string]time.Duration) (failure []string) {
        failure = make([]string, 0, len(kvs))
        for k, v := range kvs {
                var err error
                if exp, ok := expired[k]; ok {
                        err = g.instance.SetWithExpire(k, v, exp)
                } else {
                        err = g.instance.Set(k, v)
                }

                if err != nil {
                        failure = append(failure, k)
                        if g.log != nil {
                                g.log.Info(ctx, "%v [Gofusion] %s call gcache set/set_with_expire failed "+
                                        "when set cache into gcache [err[%s] key[%s]]", syscall.Getpid(), config.ComponentCache, err, k)
                        }
                }
        }
        return
}

func .convMapToInner

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/cache.go:

func (c *cache[K, T, TS]) convMapToInner(ctx context.Context, kvs map[K]T, conf *parsedConf[K, T]) (
        inner map[string]any, innerFailureKeys []string) {
        inner = make(map[string]any, len(kvs))
        for k, v := range kvs {
                innerKey := c.convKeyToInner(k, conf.version)
                innerVal, err := c.convValToInner(v, conf)
                if err != nil {
                        if conf.log != nil {
                                conf.log.Info(ctx, "%v [Gofusion] %s convert value to inner failed [err[%s] key[%+v] val[%+v]]",
                                        syscall.Getpid(), config.ComponentCache, err, k, v)
                        }
                        innerFailureKeys = append(innerFailureKeys, innerKey)
                        continue
                }
                inner[innerKey] = innerVal
        }
        return
}

func .GetAll

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/cache.go:

func (c *cache[K, T, TS]) GetAll(ctx context.Context, cb callback[K, T]) (ts TS) {
        conf := c.getConfig()
        allInnerKeys := c.visited.Items()
        cached, missed := c.provider.get(ctx, allInnerKeys...)
        kvs, _ := c.convInnerToMap(ctx, cached, conf)
        if len(missed) > 0 && (cb != nil || conf.callback != nil) {
                keys := c.convInnerToKeys(missed, conf.version)
                if conf.log != nil {
                        conf.log.Info(ctx, "%v [Gofusion] %s call callback function because we do not hit the cache "+
                                "when get all [keys%+v]", syscall.Getpid(), config.ComponentCache, keys)
                }

                var (
                        callbackKVs map[K]T
                        opts        []utils.OptionExtender
                )
                if cb != nil {
                        callbackKVs, opts = cb(ctx, keys)
                } else {
                        callbackKVs, opts = conf.callback(ctx, keys)
                }

                kvs = utils.MapMerge(kvs, callbackKVs)

                innerVals, _ := c.convMapToInner(ctx, callbackKVs, conf)
                c.provider.set(ctx, innerVals, c.parseCallbackOption(kvs, conf, opts...))
        }

        // order by param -> keys
        ts = make(TS, 0, len(kvs))
        missedKeys := make([]K, 0, len(allInnerKeys))
        for _, k := range c.convInnerToKeys(allInnerKeys, conf.version) {
                v, ok := kvs[k]
                if !ok {
                        missedKeys = append(missedKeys, k)
                        continue
                }

                ts = append(ts, v)
        }
        c.visited.Remove(c.convKeysToInner(missedKeys, conf.version)...)
        if len(missedKeys) > 0 && conf.log != nil {
                conf.log.Warn(ctx, "%v [Gofusion] %s index key value failed when cache get all [keys%v]",
                        syscall.Getpid(), config.ComponentCache, missedKeys)
        }

        return
}

func addInstance

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/construct.go:

func addInstance(ctx context.Context, conf *Conf) {
        switch conf.CacheType {
        case cacheTypeLocal:
        case cacheTypeRemote:
                if conf.RemoteType != remoteTypeRedis {
                        panic(UnknownRemoteType)
                }

                parsedSerializeType := serialize.ParseAlgorithm(conf.SerializeType)
                parsedCompressType := compress.ParseAlgorithm(conf.Compress)
                if !parsedSerializeType.IsValid() && !parsedCompressType.IsValid() {
                        panic(UnknownSerializeType)
                }
        case cacheTypeRemoteLocal:
                panic(ErrNotImplement)

        default:
                panic(UnknownCacheType)
        }

        if utils.IsStrNotBlank(conf.Callback) && inspect.FuncOf(conf.Callback) == nil {
                panic(errors.Errorf("not found callback function: %s", conf.Callback))
        }
}

func newGCache

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/local.go:

func newGCache(size int, strategy string, log log.Loggable) *gCache {
        cacheBuilder := gcache.New(size)
        switch strategy {
        case gcache.TYPE_ARC:
                cacheBuilder = cacheBuilder.ARC()
        case gcache.TYPE_LFU:
                cacheBuilder = cacheBuilder.LFU()
        case gcache.TYPE_LRU:
                cacheBuilder = cacheBuilder.LRU()
        case gcache.TYPE_SIMPLE:
                cacheBuilder = cacheBuilder.Simple()
        default:
                cacheBuilder = cacheBuilder.ARC()
        }

        return &gCache{
                log:      log,
                instance: cacheBuilder.Build(),
        }
}

func .cloneVal

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/cache.go:

func (c *cache[K, T, TS]) cloneVal(src T) (dst T) {
        if cl, ok := any(src).(clone.Clonable[T]); ok {
                dst = cl.Clone()
                return
        }
        return clone.Slowly(src)
}

func @21:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cache/construct.go:

21	`func() {`
22
23	`}`

Package Overview: github.com/wfusion/gofusion/common/constant 75.0%

Please select a function to see what's left for testing.

DefaultLocation(...) github.com/wfusion/gofusion/common/constant/time_format.go 75.0% 3/4

func DefaultLocation

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/constant/time_format.go:

func DefaultLocation() *time.Location {
        loc, err := time.LoadLocation(DefaultTimezone)
        if err != nil {
                panic(err)
        }
        return loc
}

Package Overview: github.com/wfusion/gofusion/common/di 69.0%

Please select a function to see what's left for testing.

`_dig.MustProvide(...)`	`github.com/wfusion/gofusion/common/di/dig.go`	`100.0%`	`2/2`
`Name(...)`	`github.com/wfusion/gofusion/common/di/dig.go`	`100.0%`	`1/1`
`@40:9(...)`	`github.com/wfusion/gofusion/common/di/dig.go`	`100.0%`	`1/1`
`_dig.Clear(...)`	`github.com/wfusion/gofusion/common/di/dig.go`	`100.0%`	`1/1`
`_dig.Invoke(...)`	`github.com/wfusion/gofusion/common/di/dig.go`	`100.0%`	`1/1`
`_dig.MustInvoke(...)`	`github.com/wfusion/gofusion/common/di/dig.go`	`100.0%`	`1/1`
`NewDI(...)`	`github.com/wfusion/gofusion/common/di/dig.go`	`100.0%`	`1/1`
`_dig.Preload(...)`	`github.com/wfusion/gofusion/common/di/dig.go`	`87.5%`	`14/16`
`_dig.Provide(...)`	`github.com/wfusion/gofusion/common/di/dig.go`	`87.5%`	`7/8`
`_dig.addFields(...)`	`github.com/wfusion/gofusion/common/di/dig.go`	`55.0%`	`11/20`
`_dig.MustDecorate(...)`	`github.com/wfusion/gofusion/common/di/dig.go`	`0.0%`	`0/2`
`_dig.Decorate(...)`	`github.com/wfusion/gofusion/common/di/dig.go`	`0.0%`	`0/1`
`_dig.String(...)`	`github.com/wfusion/gofusion/common/di/dig.go`	`0.0%`	`0/1`
`@46:9(...)`	`github.com/wfusion/gofusion/common/di/dig.go`	`0.0%`	`0/1`
`Group(...)`	`github.com/wfusion/gofusion/common/di/dig.go`	`0.0%`	`0/1`

func _dig.MustProvide

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/di/dig.go:

66	`func (d *_dig) MustProvide(ctor any, opts ...utils.OptionExtender) DI {`
67	`utils.MustSuccess(d.Provide(ctor, opts...))`
68	`return d`
69	`}`

func Name

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/di/dig.go:

func Name(name string) utils.OptionFunc[provideOption] {
        return func(p *provideOption) {
                p.name = name
        }
}

func @40:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/di/dig.go:

40	`func(p *provideOption) {`
41	`p.name = name`
42	`}`

func _dig.Clear

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/di/dig.go:

80	`func (d *_dig) Clear() {`
81	`d.Container = dig.New()`
82	`}`

func _dig.Invoke

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/di/dig.go:

51	`func (d *_dig) Invoke(fn any) error { return d.Container.Invoke(fn) }`

func _dig.MustInvoke

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/di/dig.go:

52	`func (d *_dig) MustInvoke(fn any) { utils.MustSuccess(d.Container.Invoke(fn)) }`

func NewDI

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/di/dig.go:

30	`func NewDI() DI {`
31	`return &_dig{Container: dig.New()}`
32	`}`

func _dig.Preload

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/di/dig.go:

func (d *_dig) Preload() {
        fields := make([]reflect.StructField, 0, 1+len(d.fields))
        fields = append(fields, reflect.StructField{
                Name:      "In",
                PkgPath:   "",
                Type:      digInType,
                Tag:       "",
                Offset:    0,
                Index:     nil,
                Anonymous: true,
        })
        for i := 0; i < len(d.fields); i++ {
                fields = append(fields, reflect.StructField{
                        Name:      fmt.Sprintf("Arg%X", i+1),
                        PkgPath:   "",
                        Type:      d.fields[i].Type,
                        Tag:       d.fields[i].Tag,
                        Offset:    0,
                        Index:     nil,
                        Anonymous: false,
                })
        }
        structType := reflect.StructOf(fields)

        // FIXME: we cannot declare function param type dynamic now
        scope := inspect.GetField[*dig.Scope](d.Container, "scope")
        containerStoreType := inspect.TypeOf("go.uber.org/dig.containerStore")
        containerStoreVal := reflect.ValueOf(scope).Convert(containerStoreType)

        fakeParam := utils.Must(newParam(structType, scope))
        paramType := inspect.TypeOf("go.uber.org/dig.param")
        paramVal := reflect.ValueOf(fakeParam).Convert(paramType)
        buildFn := paramVal.MethodByName("Build")
        returnValList := buildFn.Call([]reflect.Value{containerStoreVal})
        if errVal := returnValList[len(returnValList)-1].Interface(); errVal != nil {
                if err, ok := errVal.(error); ok && err != nil {
                        panic(err)
                }
        }
}

func _dig.Provide

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/di/dig.go:

func (d *_dig) Provide(ctor any, opts ...utils.OptionExtender) (err error) {
        opt := utils.ApplyOptions[provideOption](opts...)
        digOpts := make([]dig.ProvideOption, 0, 2)
        if opt.name != "" {
                digOpts = append(digOpts, dig.Name(opt.name))
        }
        if opt.group != "" {
                digOpts = append(digOpts, dig.Group(opt.group))
        }

        defer d.addFields(ctor, opt)
        return d.Container.Provide(ctor, digOpts...)
}

func _dig.addFields

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/di/dig.go:

func (d *_dig) addFields(ctor any, opt *provideOption) {
        typ := reflect.TypeOf(ctor)
        numOfOut := typ.NumOut()
        for i := 0; i < numOfOut; i++ {
                out := typ.Out(i)
                // ignore error and non-interface nor non-struct out param
                if out == constant.ErrorType ||
                        (out.Kind() != reflect.Interface &&
                                (out.Kind() != reflect.Struct && !(out.Kind() == reflect.Ptr && out.Elem().Kind() == reflect.Struct))) {
                        continue
                }
                if !utils.EmbedsType(out, digOutType) {
                        var tag reflect.StructTag
                        switch {
                        case opt.name != "":
                                tag = reflect.StructTag(fmt.Sprintf(`name:"%s"`, opt.name))
                        case opt.group != "":
                                tag = reflect.StructTag(fmt.Sprintf(`group:"%s"`, opt.group))
                                out = reflect.SliceOf(out)
                        }

                        d.fields = append(d.fields, reflect.StructField{Type: out, Tag: tag})
                        continue
                }

                // traverse all field
                numOfFields := out.NumField()
                for j := 0; j < numOfFields; j++ {
                        f := out.Field(j)

                        // ignore dig out
                        if f.Type == digOutType || f.Type == outType {
                                continue
                        }

                        d.fields = append(d.fields, f)
                }
        }
}

func _dig.MustDecorate

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/di/dig.go:

71	`func (d *_dig) MustDecorate(decorator any) DI {`
72	`utils.MustSuccess(d.Container.Decorate(decorator))`
73	`return d`
74	`}`

func _dig.Decorate

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/di/dig.go:

70	`func (d *_dig) Decorate(decorator any) error { return d.Container.Decorate(decorator) }`

func _dig.String

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/di/dig.go:

76	`func (d *_dig) String() string {`
77	`return d.Container.String()`
78	`}`

func @46:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/di/dig.go:

46	`func(p *provideOption) {`
47	`p.group = group`
48	`}`

func Group

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/di/dig.go:

func Group(group string) utils.OptionFunc[provideOption] {
        return func(p *provideOption) {
                p.group = group
        }
}

Package Overview: github.com/wfusion/gofusion/common/env 61.9%

Please select a function to see what's left for testing.

`GetEnv(...)`	`github.com/wfusion/gofusion/common/env/env.go`	`100.0%`	`5/5`
`init(...)`	`github.com/wfusion/gofusion/common/env/env.go`	`100.0%`	`4/4`
`SvcName(...)`	`github.com/wfusion/gofusion/common/env/env.go`	`57.1%`	`4/7`
`IsOnline(...)`	`github.com/wfusion/gofusion/common/env/env.go`	`0.0%`	`0/1`
`IsStaging(...)`	`github.com/wfusion/gofusion/common/env/env.go`	`0.0%`	`0/1`
`IsCI(...)`	`github.com/wfusion/gofusion/common/env/env.go`	`0.0%`	`0/1`
`SetSvcName(...)`	`github.com/wfusion/gofusion/common/env/env.go`	`0.0%`	`0/1`
`IsDEV(...)`	`github.com/wfusion/gofusion/common/env/env.go`	`0.0%`	`0/1`

func GetEnv

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/env/env.go:

func GetEnv() string {
        if env != "" {
                return env
        }
        if env = os.Getenv("ENV"); env == "" {
                env = Dev
        }
        return env
}

func init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/env/env.go:

func init() {
        GetEnv()
        SvcName()

        dir, _ := filepath.Abs(filepath.Dir(os.Args[0]))
        WorkDir = dir
}

func SvcName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/env/env.go:

func SvcName() string {
        if svcName != "" {
                return svcName
        }
        if svcName = os.Getenv("SVC_NAME"); svcName != "" {
                return svcName
        }
        if svcName = os.Getenv("SERVICE_NAME"); svcName != "" {
                return svcName
        }
        return ""
}

func IsOnline

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/env/env.go:

38	`func IsOnline() bool {`
39	`return GetEnv() == Online`
40	`}`

func IsStaging

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/env/env.go:

43	`func IsStaging() bool {`
44	`return GetEnv() == Staging`
45	`}`

func IsCI

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/env/env.go:

48	`func IsCI() bool {`
49	`return GetEnv() == CI`
50	`}`

func SetSvcName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/env/env.go:

52	`func SetSvcName(name string) {`
53	`svcName = name`
54	`}`

func IsDEV

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/env/env.go:

33	`func IsDEV() bool {`
34	`return GetEnv() == Dev`
35	`}`

Package Overview: github.com/wfusion/gofusion/common/infra/drivers/mongo 89.1%

Please select a function to see what's left for testing.

`defaultDialect.wrapNumberSetter(...)`	`github.com/wfusion/gofusion/common/infra/drivers/mongo/mongo.go`	`100.0%`	`2/2`
`Mongo.GetProxy(...)`	`github.com/wfusion/gofusion/common/infra/drivers/mongo/interface.go`	`100.0%`	`1/1`
`WithMonitor(...)`	`github.com/wfusion/gofusion/common/infra/drivers/mongo/logger.go`	`100.0%`	`1/1`
`@10:9(...)`	`github.com/wfusion/gofusion/common/infra/drivers/mongo/logger.go`	`100.0%`	`1/1`
`WithPoolMonitor(...)`	`github.com/wfusion/gofusion/common/infra/drivers/mongo/logger.go`	`100.0%`	`1/1`
`@16:9(...)`	`github.com/wfusion/gofusion/common/infra/drivers/mongo/logger.go`	`100.0%`	`1/1`
`Mongo.Database(...)`	`github.com/wfusion/gofusion/common/infra/drivers/mongo/interface.go`	`100.0%`	`1/1`
`@101:39(...)`	`github.com/wfusion/gofusion/common/infra/drivers/mongo/mongo.go`	`100.0%`	`1/1`
`@102:43(...)`	`github.com/wfusion/gofusion/common/infra/drivers/mongo/mongo.go`	`100.0%`	`1/1`
`@103:45(...)`	`github.com/wfusion/gofusion/common/infra/drivers/mongo/mongo.go`	`100.0%`	`1/1`
`@104:47(...)`	`github.com/wfusion/gofusion/common/infra/drivers/mongo/mongo.go`	`100.0%`	`1/1`
`@105:49(...)`	`github.com/wfusion/gofusion/common/infra/drivers/mongo/mongo.go`	`100.0%`	`1/1`
`@106:43(...)`	`github.com/wfusion/gofusion/common/infra/drivers/mongo/mongo.go`	`100.0%`	`1/1`
`@108:41(...)`	`github.com/wfusion/gofusion/common/infra/drivers/mongo/mongo.go`	`100.0%`	`1/1`
`defaultDialect.parseOption(...)`	`github.com/wfusion/gofusion/common/infra/drivers/mongo/mongo.go`	`100.0%`	`1/1`
`defaultDialect.New(...)`	`github.com/wfusion/gofusion/common/infra/drivers/mongo/mongo.go`	`91.3%`	`21/23`
`defaultDialect.wrapDurationSetter(...)`	`github.com/wfusion/gofusion/common/infra/drivers/mongo/mongo.go`	`66.7%`	`4/6`
`@107:41(...)`	`github.com/wfusion/gofusion/common/infra/drivers/mongo/mongo.go`	`0.0%`	`0/1`

func defaultDialect.wrapNumberSetter

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/mongo/mongo.go:

func (d *defaultDialect) wrapNumberSetter(n uint64, setter func(nu uint64)) {
        if n > 0 {
                setter(n)
        }
}

func Mongo.GetProxy

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/mongo/interface.go:

26	`func (m Mongo) GetProxy() mongo.Client {`
27	`return m.Client`
28	`}`

func WithMonitor

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/mongo/logger.go:

func WithMonitor(monitor *event.CommandMonitor) utils.OptionFunc[newOption] {
        return func(o *newOption) {
                o.monitor = monitor
        }
}

func @10:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/mongo/logger.go:

10	`func(o *newOption) {`
11	`o.monitor = monitor`
12	`}`

func WithPoolMonitor

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/mongo/logger.go:

func WithPoolMonitor(monitor *event.PoolMonitor) utils.OptionFunc[newOption] {
        return func(o *newOption) {
                o.poolMonitor = monitor
        }
}

func @16:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/mongo/logger.go:

16	`func(o *newOption) {`
17	`o.poolMonitor = monitor`
18	`}`

func Mongo.Database

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/mongo/interface.go:

30	`func (m Mongo) Database(name string, opts ...options.DatabaseOptions) *mongo.Database {`
31	`return m.Client.Database(name, opts...)`
32	`}`

func @101:39

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/mongo/mongo.go:

101	`func(du time.Duration) { opt.SetTimeout(du) }`

func @102:43

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/mongo/mongo.go:

102	`func(du time.Duration) { opt.SetConnectTimeout(du) }`

func @103:45

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/mongo/mongo.go:

103	`func(du time.Duration) { opt.SetSocketTimeout(du) }`

func @104:47

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/mongo/mongo.go:

104	`func(du time.Duration) { opt.SetMaxConnIdleTime(du) }`

func @105:49

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/mongo/mongo.go:

105	`func(du time.Duration) { opt.SetHeartbeatInterval(du) }`

func @106:43

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/mongo/mongo.go:

106	`func(nu uint64) { opt.SetMaxConnecting(option.MaxConnecting) }`

func @108:41

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/mongo/mongo.go:

108	`func(nu uint64) { opt.SetMaxPoolSize(option.MaxPoolSize) }`

func defaultDialect.parseOption

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/mongo/mongo.go:

149	`func (d *defaultDialect) parseOption(option Option) (dsn string) {`
150	`return fmt.Sprintf("mongodb://%s:%s@%s/%s?authSource=%s",`
151	`option.User, option.Password, strings.Join(option.Endpoints, constant.Comma), option.DB, option.AuthDB)`
152	`}`

func defaultDialect.New

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/mongo/mongo.go:

func (d *defaultDialect) New(ctx context.Context, option Option, opts ...utils.OptionExtender) (cli *Mongo, err error) {
        opt := options.Client().ApplyURI(d.parseOption(option))
        opt.SetRetryReads(option.RetryReads)
        opt.SetRetryWrites(option.RetryWrites)
        d.wrapDurationSetter(option.Timeout, func(du time.Duration) { opt.SetTimeout(du) })
        d.wrapDurationSetter(option.ConnTimeout, func(du time.Duration) { opt.SetConnectTimeout(du) })
        d.wrapDurationSetter(option.SocketTimeout, func(du time.Duration) { opt.SetSocketTimeout(du) })
        d.wrapDurationSetter(option.MaxConnIdleTime, func(du time.Duration) { opt.SetMaxConnIdleTime(du) })
        d.wrapDurationSetter(option.HeartbeatInterval, func(du time.Duration) { opt.SetHeartbeatInterval(du) })
        d.wrapNumberSetter(option.MaxConnecting, func(nu uint64) { opt.SetMaxConnecting(option.MaxConnecting) })
        d.wrapNumberSetter(option.MinPoolSize, func(nu uint64) { opt.SetMinPoolSize(option.MinPoolSize) })
        d.wrapNumberSetter(option.MaxPoolSize, func(nu uint64) { opt.SetMaxPoolSize(option.MaxPoolSize) })

        newOpt := utils.ApplyOptions[newOption](opts...)
        if newOpt.monitor != nil {
                opt = opt.SetMonitor(newOpt.monitor)
        }
        if newOpt.poolMonitor != nil {
                opt = opt.SetPoolMonitor(newOpt.poolMonitor)
        }

        mgoCli, err := mongo.Connect(ctx, opt)
        if err != nil {
                return
        }

        // authentication check
        if err = mgoCli.Ping(ctx, nil); err != nil {
                return
        }

        cli = &Mongo{Client: mgoCli}
        return
}

func defaultDialect.wrapDurationSetter

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/mongo/mongo.go:

func (d *defaultDialect) wrapDurationSetter(s string, setter func(du time.Duration)) {
        if utils.IsStrBlank(s) {
                return
        }
        duration, err := time.ParseDuration(s)
        if err != nil {
                panic(err)
        }
        setter(duration)
}

func @107:41

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/mongo/mongo.go:

107	`func(nu uint64) { opt.SetMinPoolSize(option.MinPoolSize) }`

Package Overview: github.com/wfusion/gofusion/common/infra/drivers/orm 75.3%

Please select a function to see what's left for testing.

`gormDriver.parseDBOption(...)`	`github.com/wfusion/gofusion/common/infra/drivers/orm/gorm.go`	`100.0%`	`10/10`
`gormDriver.genSqlServerDsn(...)`	`github.com/wfusion/gofusion/common/infra/drivers/orm/gorm.go`	`100.0%`	`6/6`
`DB.WithContext(...)`	`github.com/wfusion/gofusion/common/infra/drivers/orm/interface.go`	`100.0%`	`2/2`
`gormDriver.genPostgresDsn(...)`	`github.com/wfusion/gofusion/common/infra/drivers/orm/gorm.go`	`100.0%`	`2/2`
`DB.GetProxy(...)`	`github.com/wfusion/gofusion/common/infra/drivers/orm/interface.go`	`100.0%`	`1/1`
`WithLogger(...)`	`github.com/wfusion/gofusion/common/infra/drivers/orm/logger.go`	`100.0%`	`1/1`
`@10:9(...)`	`github.com/wfusion/gofusion/common/infra/drivers/orm/logger.go`	`100.0%`	`1/1`
`gormDriver.New(...)`	`github.com/wfusion/gofusion/common/infra/drivers/orm/gorm.go`	`90.5%`	`19/21`
`gormDriver.open(...)`	`github.com/wfusion/gofusion/common/infra/drivers/orm/gorm.go`	`75.0%`	`9/12`
`gormDriver.genMySqlDsn(...)`	`github.com/wfusion/gofusion/common/infra/drivers/orm/gorm.go`	`66.7%`	`4/6`
`gormDriver.genClickhouseDsn(...)`	`github.com/wfusion/gofusion/common/infra/drivers/orm/gorm.go`	`0.0%`	`0/10`
`DB.GetDialector(...)`	`github.com/wfusion/gofusion/common/infra/drivers/orm/interface.go`	`0.0%`	`0/1`

func gormDriver.parseDBOption

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/orm/gorm.go:

func (g *gormDriver) parseDBOption(option Option) (parsed *gormDriverOption) {
        parsed = &gormDriverOption{
                Driver:       option.Driver,
                Dialect:      option.Dialect,
                Timeout:      option.Timeout,
                ReadTimeout:  option.ReadTimeout,
                WriteTimeout: option.WriteTimeout,
                User:         option.User,
                Password:     option.Password,
                DBName:       option.DB,
                DBCharset:    "utf8mb4,utf8",
                DBHostname:   option.Host,
                DBPort:       fmt.Sprintf("%v", option.Port),
                Scheme:       "tcp",
        }

        if option.Driver != "" {
                parsed.Driver = option.Driver
        }
        if option.MaxIdleConns > 0 {
                parsed.MaxIdleConns = option.MaxIdleConns
        }
        if option.MaxOpenConns > 0 {
                parsed.MaxOpenConns = option.MaxOpenConns
        }

        if utils.IsStrBlank(string(parsed.Dialect)) {
                parsed.Dialect = defaultDriverDialectMapping[parsed.Driver]
        }

        return
}

func gormDriver.genSqlServerDsn

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/orm/gorm.go:

func (g *gormDriver) genSqlServerDsn(opt *gormDriverOption) (dsn string) {
        const (
                dsnFormat = "sqlserver://%s:%s@%s:%s?database=%s&connection+timeout=%s"
        )

        timeout := "5" // seconds
        if utils.IsStrNotBlank(opt.Timeout) {
                if duration, err := time.ParseDuration(opt.Timeout); err == nil {
                        timeout = fmt.Sprintf("%v", int(duration/time.Second))
                }
        }

        return fmt.Sprintf(dsnFormat, opt.User, opt.Password, opt.DBHostname, opt.DBPort, opt.DBName, timeout)
}

func DB.WithContext

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/orm/interface.go:

52	`func (d DB) WithContext(ctx context.Context) DB {`
53	`d.DB = d.DB.WithContext(ctx)`
54	`return d`
55	`}`

func gormDriver.genPostgresDsn

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/orm/gorm.go:

func (g *gormDriver) genPostgresDsn(opt *gormDriverOption) (dsn string) {
        const (
                dsnFormat = "host=%s user=%s password=%s dbname=%s port=%s sslmode=disable TimeZone=Asia/Shanghai"
        )

        return fmt.Sprintf(dsnFormat, opt.DBHostname, opt.User, opt.Password, opt.DBName, opt.DBPort)
}

func DB.GetProxy

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/orm/interface.go:

44	`func (d DB) GetProxy() gorm.DB {`
45	`return d.DB`
46	`}`

func WithLogger

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/orm/logger.go:

func WithLogger(l logger.Interface) utils.OptionFunc[newOption] {
        return func(o *newOption) {
                o.logger = l
        }
}

func @10:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/orm/logger.go:

10	`func(o *newOption) {`
11	`o.logger = l`
12	`}`

func gormDriver.New

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/orm/gorm.go:

func (g *gormDriver) New(ctx context.Context, option Option, opts ...utils.OptionExtender) (db *DB, err error) {
        opt := g.parseDBOption(option)
        gormDB, dialector, err := g.open(opt.Driver, string(opt.Dialect), opt)
        if err != nil {
                return
        }

        sqlDB, err := gormDB.DB()
        if err != nil {
                return
        }

        // optional
        if opt.MaxOpenConns > 0 {
                sqlDB.SetMaxOpenConns(opt.MaxOpenConns)
        }
        if opt.MaxIdleConns > 0 {
                sqlDB.SetMaxIdleConns(opt.MaxIdleConns)
        }
        if utils.IsStrNotBlank(option.ConnMaxLifeTime) {
                if liftTime, err := time.ParseDuration(option.ConnMaxLifeTime); err == nil {
                        sqlDB.SetConnMaxLifetime(liftTime)
                }
        }
        if utils.IsStrNotBlank(option.ConnMaxLifeTime) {
                if idleTime, err := time.ParseDuration(option.ConnMaxIdleTime); err == nil {
                        sqlDB.SetConnMaxIdleTime(idleTime)
                }
        }

        newOpt := utils.ApplyOptions[newOption](opts...)
        if newOpt.logger != nil {
                gormDB.Logger = newOpt.logger
        }

        return &DB{DB: gormDB.WithContext(ctx), dialector: dialector}, nil
}

func gormDriver.open

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/orm/gorm.go:

func (g *gormDriver) open(driver driver, dialect string, opt *gormDriverOption) (
        db *gorm.DB, dialector gorm.Dialector, err error) {
        // alternative driver
        switch driver {
        case DriverMysql:
                dialector = mysql.New(mysql.Config{
                        DriverName: dialect,
                        DSN:        g.genMySqlDsn(opt),
                })

        case DriverPostgres:
                if dialect == string(DialectOpenGauss) {
                        dialector = opengauss.New(opengauss.Config{
                                DriverName: dialect,
                                DSN:        g.genPostgresDsn(opt),
                        })
                } else {
                        dialector = postgres.New(postgres.Config{
                                DriverName: dialect,
                                DSN:        g.genPostgresDsn(opt),
                        })
                }

        // sqlite dsn is filepath
        // or file::memory:?cache=shared is also available, see also https://www.sqlite.org/inmemorydb.html
        case DriverSqlite:
                dialector = sqlite.Open(path.Join(env.WorkDir, path.Clean(opt.DBName)))

        case DriverSqlserver:
                dialector = sqlserver.New(sqlserver.Config{
                        DriverName: dialect,
                        DSN:        g.genSqlServerDsn(opt),
                })

        // tidb is compatible with mysql protocol
        case DriverTiDB:
                dialector = mysql.New(mysql.Config{
                        DriverName: dialect,
                        DSN:        g.genMySqlDsn(opt),
                })

        case DriverClickhouse:
                dialector = clickhouse.New(clickhouse.Config{
                        DriverName: dialect,
                        DSN:        g.genClickhouseDsn(opt),
                })

        default:
                panic(errors.Errorf("unknown db driver or dialect: %s %s", driver, dialect))
        }

        db, err = gorm.Open(dialector, &gorm.Config{
                DisableForeignKeyConstraintWhenMigrating: true,
        })
        return
}

func gormDriver.genMySqlDsn

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/orm/gorm.go:

func (g *gormDriver) genMySqlDsn(opt *gormDriverOption) (dsn string) {
        if opt.DBCharset == "" {
                opt.DBCharset = "utf8"
        }
        if opt.Scheme == "" {
                opt.Scheme = "tcp"
        }

        const (
                dsnFormat = "%s:%s@%s(%s:%s)/%s?charset=%s&parseTime=True&loc=Local&timeout=%s&readTimeout=%s&writeTimeout=%s"
        )

        return fmt.Sprintf(dsnFormat, opt.User, opt.Password, opt.Scheme, opt.DBHostname, opt.DBPort, opt.DBName,
                opt.DBCharset, opt.Timeout, opt.ReadTimeout, opt.WriteTimeout)
}

func gormDriver.genClickhouseDsn

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/orm/gorm.go:

func (g *gormDriver) genClickhouseDsn(opt *gormDriverOption) (dsn string) {
        const (
                dsnFormat = "tcp://%s:%s?database=%s&username=%s&password=%s&read_timeout=%s&write_timeout=%s"
        )

        readTimeout := "2" // seconds
        if utils.IsStrNotBlank(opt.ReadTimeout) {
                if duration, err := time.ParseDuration(opt.ReadTimeout); err == nil {
                        readTimeout = fmt.Sprintf("%v", int(duration/time.Second))
                }
        }
        writeTimeout := "2" // seconds
        if utils.IsStrNotBlank(opt.ReadTimeout) {
                if duration, err := time.ParseDuration(opt.WriteTimeout); err == nil {
                        writeTimeout = fmt.Sprintf("%v", int(duration/time.Second))
                }
        }

        return fmt.Sprintf(dsnFormat, opt.DBHostname, opt.DBPort, opt.DBName, opt.User, opt.Password,
                readTimeout, writeTimeout)
}

func DB.GetDialector

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/orm/interface.go:

48	`func (d *DB) GetDialector() gorm.Dialector {`
49	`return d.dialector`
50	`}`

Package Overview: github.com/wfusion/gofusion/common/infra/drivers/orm/idgen 87.5%

Please select a function to see what's left for testing.

`NewSnowflake(...)`	`github.com/wfusion/gofusion/common/infra/drivers/orm/idgen/snowflake.go`	`100.0%`	`2/2`
`GormTx(...)`	`github.com/wfusion/gofusion/common/infra/drivers/orm/idgen/interface.go`	`100.0%`	`1/1`
`snowflake.Next(...)`	`github.com/wfusion/gofusion/common/infra/drivers/orm/idgen/snowflake.go`	`100.0%`	`1/1`
`@36:15(...)`	`github.com/wfusion/gofusion/common/infra/drivers/orm/idgen/snowflake.go`	`93.3%`	`14/15`
`@32:19(...)`	`github.com/wfusion/gofusion/common/infra/drivers/orm/idgen/snowflake.go`	`75.0%`	`3/4`
`@26:9(...)`	`github.com/wfusion/gofusion/common/infra/drivers/orm/idgen/interface.go`	`0.0%`	`0/1`

func NewSnowflake

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/orm/idgen/snowflake.go:

func NewSnowflake() Generator {
        snowflakeOnce.Do(func() {
                flake := sonyflake.NewSonyflake(sonyflake.Settings{
                        StartTime: time.Time{},
                        // machine id: hash(host ip + local ip + pid)(8 bit) - local ip(8 bit)
                        MachineID: func() (id uint16, err error) {
                                pid := os.Getpid()
                                hostIP := utils.HostIPInDocker()
                                localIP := utils.ClientIP()
                                log.Printf("[Common] snowflake get machine id base [host[%s] local[%s] pid[%v]]", hostIP, localIP, pid)
                                if hostIP == "" {
                                        hostIP = utils.ClientIP()
                                }
                                hash := fnv.New32a()
                                _, err = hash.Write([]byte(fmt.Sprintf("%s%s%v", hostIP, localIP, pid)))
                                if err != nil {
                                        return
                                }

                                high := byte(hash.Sum32() % 255)
                                low := net.ParseIP(localIP).To4()[3]
                                id = uint16(high)<<8 | uint16(low)
                                log.Printf("[Common] snowflake get machine id [%X]", id)
                                return
                        },
                        CheckMachineID: nil,
                })
                if flake == nil {
                        panic(ErrNewGenerator)
                }
                snowflakeInstance = &snowflake{instance: flake}
        })

        return snowflakeInstance
}

func GormTx

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/orm/idgen/interface.go:

func GormTx(tx *gorm.DB) utils.OptionFunc[option] {
        return func(o *option) {
                o.tx = tx
        }
}

func snowflake.Next

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/orm/idgen/snowflake.go:

67	`func (s *snowflake) Next(opts ...utils.OptionExtender) (id uint64, err error) {`
68	`return s.instance.NextID()`
69	`}`

func @36:15

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/orm/idgen/snowflake.go:

func() (id uint16, err error) {
                                pid := os.Getpid()
                                hostIP := utils.HostIPInDocker()
                                localIP := utils.ClientIP()
                                log.Printf("[Common] snowflake get machine id base [host[%s] local[%s] pid[%v]]", hostIP, localIP, pid)
                                if hostIP == "" {
                                        hostIP = utils.ClientIP()
                                }
                                hash := fnv.New32a()
                                _, err = hash.Write([]byte(fmt.Sprintf("%s%s%v", hostIP, localIP, pid)))
                                if err != nil {
                                        return
                                }

                                high := byte(hash.Sum32() % 255)
                                low := net.ParseIP(localIP).To4()[3]
                                id = uint16(high)<<8 | uint16(low)
                                log.Printf("[Common] snowflake get machine id [%X]", id)
                                return
                        }

func @32:19

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/orm/idgen/snowflake.go:

func() {
                flake := sonyflake.NewSonyflake(sonyflake.Settings{
                        StartTime: time.Time{},
                        // machine id: hash(host ip + local ip + pid)(8 bit) - local ip(8 bit)
                        MachineID: func() (id uint16, err error) {
                                pid := os.Getpid()
                                hostIP := utils.HostIPInDocker()
                                localIP := utils.ClientIP()
                                log.Printf("[Common] snowflake get machine id base [host[%s] local[%s] pid[%v]]", hostIP, localIP, pid)
                                if hostIP == "" {
                                        hostIP = utils.ClientIP()
                                }
                                hash := fnv.New32a()
                                _, err = hash.Write([]byte(fmt.Sprintf("%s%s%v", hostIP, localIP, pid)))
                                if err != nil {
                                        return
                                }

                                high := byte(hash.Sum32() % 255)
                                low := net.ParseIP(localIP).To4()[3]
                                id = uint16(high)<<8 | uint16(low)
                                log.Printf("[Common] snowflake get machine id [%X]", id)
                                return
                        },
                        CheckMachineID: nil,
                })
                if flake == nil {
                        panic(ErrNewGenerator)
                }
                snowflakeInstance = &snowflake{instance: flake}
        }

func @26:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/orm/idgen/interface.go:

26	`func(o *option) {`
27	`o.tx = tx`
28	`}`

Package Overview: github.com/wfusion/gofusion/common/infra/drivers/redis 47.1%

Please select a function to see what's left for testing.

`@47:44(...)`	`github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go`	`100.0%`	`1/1`
`@10:9(...)`	`github.com/wfusion/gofusion/common/infra/drivers/redis/hook.go`	`100.0%`	`1/1`
`Redis.GetProxy(...)`	`github.com/wfusion/gofusion/common/infra/drivers/redis/interface.go`	`100.0%`	`1/1`
`@48:45(...)`	`github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go`	`100.0%`	`1/1`
`WithHook(...)`	`github.com/wfusion/gofusion/common/infra/drivers/redis/hook.go`	`100.0%`	`1/1`
`@49:48(...)`	`github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go`	`100.0%`	`1/1`
`defaultDialect.parseOption(...)`	`github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go`	`100.0%`	`1/1`
`@46:44(...)`	`github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go`	`100.0%`	`1/1`
`@52:48(...)`	`github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go`	`100.0%`	`1/1`
`@51:48(...)`	`github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go`	`100.0%`	`1/1`
`@50:48(...)`	`github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go`	`100.0%`	`1/1`
`defaultDialect.wrapDurationSetter(...)`	`github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go`	`83.3%`	`5/6`
`defaultDialect.New(...)`	`github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go`	`48.5%`	`16/33`
`Redis.PoolStatus(...)`	`github.com/wfusion/gofusion/common/infra/drivers/redis/interface.go`	`0.0%`	`0/4`
`Redis.Close(...)`	`github.com/wfusion/gofusion/common/infra/drivers/redis/interface.go`	`0.0%`	`0/4`
`@26:48(...)`	`github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go`	`0.0%`	`0/1`
`@45:44(...)`	`github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go`	`0.0%`	`0/1`
`@27:48(...)`	`github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go`	`0.0%`	`0/1`
`@25:48(...)`	`github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go`	`0.0%`	`0/1`
`@24:48(...)`	`github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go`	`0.0%`	`0/1`
`@23:45(...)`	`github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go`	`0.0%`	`0/1`
`@22:44(...)`	`github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go`	`0.0%`	`0/1`
`@21:44(...)`	`github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go`	`0.0%`	`0/1`
`@20:44(...)`	`github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go`	`0.0%`	`0/1`
`defaultDialect.parseClusterOption(...)`	`github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go`	`0.0%`	`0/1`

func @47:44

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go:

47	`func(du time.Duration) { opt.ReadTimeout = du }`

func @10:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/redis/hook.go:

10	`func(o *newOption) {`
11	`o.hooks = append(o.hooks, hooks...)`
12	`}`

func Redis.GetProxy

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/redis/interface.go:

86	`func (r *Redis) GetProxy() redis.UniversalClient {`
87	`return r.redis`
88	`}`

func @48:45

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go:

48	`func(du time.Duration) { opt.WriteTimeout = du }`

func WithHook

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/redis/hook.go:

func WithHook(hooks []redis.Hook) utils.OptionFunc[newOption] {
        return func(o *newOption) {
                o.hooks = append(o.hooks, hooks...)
        }
}

func @49:48

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go:

49	`func(du time.Duration) { opt.ConnMaxIdleTime = du }`

func defaultDialect.parseOption

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go:

func (d *defaultDialect) parseOption(option Option) (cfg *redis.Options) {
        return &redis.Options{
                Addr:         option.Endpoints[0],
                Username:     option.User,
                Password:     option.Password,
                MaxRetries:   option.MaxRetries,
                MinIdleConns: option.MinIdleConns,
                MaxIdleConns: option.MaxIdleConns,
                PoolSize:     option.PoolSize,
        }
}

func @46:44

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go:

46	`func(du time.Duration) { opt.DialTimeout = du }`

func @52:48

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go:

52	`func(du time.Duration) { opt.MaxRetryBackoff = du }`

func @51:48

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go:

51	`func(du time.Duration) { opt.MinRetryBackoff = du }`

func @50:48

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go:

50	`func(du time.Duration) { opt.ConnMaxLifetime = du }`

func defaultDialect.wrapDurationSetter

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go:

func (d *defaultDialect) wrapDurationSetter(s string, setter func(du time.Duration)) {
        if utils.IsStrBlank(s) {
                return
        }
        duration, err := time.ParseDuration(s)
        if err != nil {
                panic(err)
        }
        setter(duration)
}

func defaultDialect.New

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go:

func (d *defaultDialect) New(ctx context.Context, option Option, opts ...utils.OptionExtender) (
        r *Redis, err error) {
        if option.Cluster {
                opt := d.parseClusterOption(option)
                d.wrapDurationSetter(option.PoolTimeout, func(du time.Duration) { opt.PoolTimeout = du })
                d.wrapDurationSetter(option.DialTimeout, func(du time.Duration) { opt.DialTimeout = du })
                d.wrapDurationSetter(option.ReadTimeout, func(du time.Duration) { opt.ReadTimeout = du })
                d.wrapDurationSetter(option.WriteTimeout, func(du time.Duration) { opt.WriteTimeout = du })
                d.wrapDurationSetter(option.ConnMaxIdleTime, func(du time.Duration) { opt.ConnMaxIdleTime = du })
                d.wrapDurationSetter(option.ConnMaxLifetime, func(du time.Duration) { opt.ConnMaxLifetime = du })
                d.wrapDurationSetter(option.MinRetryBackoff, func(du time.Duration) { opt.MinRetryBackoff = du })
                d.wrapDurationSetter(option.MaxRetryBackoff, func(du time.Duration) { opt.MaxRetryBackoff = du })

                rdsCli := redis.NewClusterClient(opt)

                // authentication check
                if err = rdsCli.Ping(context.Background()).Err(); err != nil {
                        return
                }

                newOpt := utils.ApplyOptions[newOption](opts...)
                for _, hook := range newOpt.hooks {
                        rdsCli.AddHook(hook)
                }

                return &Redis{redis: rdsCli}, nil

        } else {
                opt := d.parseOption(option)
                d.wrapDurationSetter(option.PoolTimeout, func(du time.Duration) { opt.PoolTimeout = du })
                d.wrapDurationSetter(option.DialTimeout, func(du time.Duration) { opt.DialTimeout = du })
                d.wrapDurationSetter(option.ReadTimeout, func(du time.Duration) { opt.ReadTimeout = du })
                d.wrapDurationSetter(option.WriteTimeout, func(du time.Duration) { opt.WriteTimeout = du })
                d.wrapDurationSetter(option.ConnMaxIdleTime, func(du time.Duration) { opt.ConnMaxIdleTime = du })
                d.wrapDurationSetter(option.ConnMaxLifetime, func(du time.Duration) { opt.ConnMaxLifetime = du })
                d.wrapDurationSetter(option.MinRetryBackoff, func(du time.Duration) { opt.MinRetryBackoff = du })
                d.wrapDurationSetter(option.MaxRetryBackoff, func(du time.Duration) { opt.MaxRetryBackoff = du })

                rdsCli := redis.NewClient(opt)

                // authentication check
                if err = rdsCli.Ping(context.Background()).Err(); err != nil {
                        return
                }

                newOpt := utils.ApplyOptions[newOption](opts...)
                for _, hook := range newOpt.hooks {
                        rdsCli.AddHook(hook)
                }

                return &Redis{redis: rdsCli}, nil
        }
}

func Redis.PoolStatus

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/redis/interface.go:

func (r *Redis) PoolStatus() *redis.PoolStats {
        switch rdsCli := r.redis.(type) {
        case *redis.ClusterClient:
                return rdsCli.PoolStats()
        case *redis.Client:
                return rdsCli.PoolStats()
        default:
                return new(redis.PoolStats)
        }
}

func Redis.Close

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/redis/interface.go:

func (r *Redis) Close() error {
        switch rdsCli := r.redis.(type) {
        case *redis.ClusterClient:
                return rdsCli.Close()
        case *redis.Client:
                return rdsCli.Close()
        default:
                return nil
        }
}

func @26:48

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go:

26	`func(du time.Duration) { opt.MinRetryBackoff = du }`

func @45:44

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go:

45	`func(du time.Duration) { opt.PoolTimeout = du }`

func @27:48

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go:

27	`func(du time.Duration) { opt.MaxRetryBackoff = du }`

func @25:48

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go:

25	`func(du time.Duration) { opt.ConnMaxLifetime = du }`

func @24:48

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go:

24	`func(du time.Duration) { opt.ConnMaxIdleTime = du }`

func @23:45

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go:

23	`func(du time.Duration) { opt.WriteTimeout = du }`

func @22:44

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go:

22	`func(du time.Duration) { opt.ReadTimeout = du }`

func @21:44

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go:

21	`func(du time.Duration) { opt.DialTimeout = du }`

func @20:44

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go:

20	`func(du time.Duration) { opt.PoolTimeout = du }`

func defaultDialect.parseClusterOption

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/infra/drivers/redis/redis.go:

func (d *defaultDialect) parseClusterOption(option Option) (cfg *redis.ClusterOptions) {
        return &redis.ClusterOptions{
                Addrs:        option.Endpoints,
                Username:     option.User,
                Password:     option.Password,
                MaxRetries:   option.MaxRetries,
                MinIdleConns: option.MinIdleConns,
                MaxIdleConns: option.MaxIdleConns,
                PoolSize:     option.PoolSize,
        }
}

Package Overview: github.com/wfusion/gofusion/common/utils 56.4%

Please select a function to see what's left for testing.

`NginxID(...)`	`github.com/wfusion/gofusion/common/utils/random.go`	`100.0%`	`22/22`
`GetCaller(...)`	`github.com/wfusion/gofusion/common/utils/func.go`	`100.0%`	`14/14`
`.init(...)`	`github.com/wfusion/gofusion/common/utils/enum.go`	`100.0%`	`12/12`
`FuzzyKeyword(...)`	`github.com/wfusion/gofusion/common/utils/string.go`	`100.0%`	`10/10`
`@117:9(...)`	`github.com/wfusion/gofusion/common/utils/time.go`	`100.0%`	`9/9`
`Set[T].Items(...)`	`github.com/wfusion/gofusion/common/utils/sets.go`	`100.0%`	`8/8`
`SliceMapping(...)`	`github.com/wfusion/gofusion/common/utils/conv.go`	`100.0%`	`6/6`
`MapMerge(...)`	`github.com/wfusion/gofusion/common/utils/map.go`	`100.0%`	`6/6`
`poolBytes.Reset(...)`	`github.com/wfusion/gofusion/common/utils/pool.go`	`100.0%`	`5/5`
`Set[T].Remove(...)`	`github.com/wfusion/gofusion/common/utils/sets.go`	`100.0%`	`5/5`
`Set[T].Insert(...)`	`github.com/wfusion/gofusion/common/utils/sets.go`	`100.0%`	`5/5`
`ApplyOptions(...)`	`github.com/wfusion/gofusion/common/utils/options.go`	`100.0%`	`5/5`
`RandomLetterAndNumber(...)`	`github.com/wfusion/gofusion/common/utils/random.go`	`100.0%`	`5/5`
`@61:14(...)`	`github.com/wfusion/gofusion/common/utils/ip.go`	`100.0%`	`5/5`
`@133:14(...)`	`github.com/wfusion/gofusion/common/utils/random.go`	`100.0%`	`5/5`
`GetCtxAny(...)`	`github.com/wfusion/gofusion/common/utils/context.go`	`100.0%`	`5/5`
`LookupByFuzzyKeyword(...)`	`github.com/wfusion/gofusion/common/utils/candy.go`	`100.0%`	`5/5`
`ParseTag(...)`	`github.com/wfusion/gofusion/common/utils/tag.go`	`100.0%`	`4/4`
`.Enum(...)`	`github.com/wfusion/gofusion/common/utils/enum.go`	`100.0%`	`4/4`
`NewSet(...)`	`github.com/wfusion/gofusion/common/utils/sets.go`	`100.0%`	`4/4`
`SliceToMap(...)`	`github.com/wfusion/gofusion/common/utils/map.go`	`100.0%`	`4/4`
`@45:9(...)`	`github.com/wfusion/gofusion/common/utils/func.go`	`100.0%`	`4/4`
`Set[T].Contains(...)`	`github.com/wfusion/gofusion/common/utils/sets.go`	`100.0%`	`4/4`
`Random(...)`	`github.com/wfusion/gofusion/common/utils/random.go`	`100.0%`	`4/4`
`ErrIgnore(...)`	`github.com/wfusion/gofusion/common/utils/candy.go`	`100.0%`	`4/4`
`@126:11(...)`	`github.com/wfusion/gofusion/common/utils/random.go`	`100.0%`	`4/4`
`SliceReverse(...)`	`github.com/wfusion/gofusion/common/utils/slice.go`	`100.0%`	`3/3`
`IfAny(...)`	`github.com/wfusion/gofusion/common/utils/candy.go`	`100.0%`	`3/3`
`GetGormColumnValue(...)`	`github.com/wfusion/gofusion/common/utils/reflect.go`	`100.0%`	`3/3`
`@159:5(...)`	`github.com/wfusion/gofusion/common/utils/time.go`	`100.0%`	`3/3`
`@89:11(...)`	`github.com/wfusion/gofusion/common/utils/pool.go`	`100.0%`	`2/2`
`.IsValid(...)`	`github.com/wfusion/gofusion/common/utils/enum.go`	`100.0%`	`2/2`
`OptionFunc[T].applyOption(...)`	`github.com/wfusion/gofusion/common/utils/options.go`	`100.0%`	`2/2`
`@182:9(...)`	`github.com/wfusion/gofusion/common/utils/func.go`	`100.0%`	`2/2`
`MustJsonUnmarshal(...)`	`github.com/wfusion/gofusion/common/utils/marshal.go`	`100.0%`	`2/2`
`@176:3(...)`	`github.com/wfusion/gofusion/common/utils/random.go`	`100.0%`	`2/2`
`init(...)`	`github.com/wfusion/gofusion/common/utils/random.go`	`100.0%`	`2/2`
`@190:9(...)`	`github.com/wfusion/gofusion/common/utils/func.go`	`100.0%`	`2/2`
`NewPool(...)`	`github.com/wfusion/gofusion/common/utils/pool.go`	`100.0%`	`2/2`
`@34:9(...)`	`github.com/wfusion/gofusion/common/utils/func.go`	`100.0%`	`2/2`
`WrapFunc2(...)`	`github.com/wfusion/gofusion/common/utils/func.go`	`100.0%`	`1/1`
`WrapFunc1(...)`	`github.com/wfusion/gofusion/common/utils/func.go`	`100.0%`	`1/1`
`@39:36(...)`	`github.com/wfusion/gofusion/common/utils/string.go`	`100.0%`	`1/1`
`MustJsonMarshal(...)`	`github.com/wfusion/gofusion/common/utils/marshal.go`	`100.0%`	`1/1`
`@17:9(...)`	`github.com/wfusion/gofusion/common/utils/func.go`	`100.0%`	`1/1`
`@177:19(...)`	`github.com/wfusion/gofusion/common/utils/random.go`	`100.0%`	`1/1`
`WrapFunc(...)`	`github.com/wfusion/gofusion/common/utils/func.go`	`100.0%`	`1/1`
`GetFuncName(...)`	`github.com/wfusion/gofusion/common/utils/func.go`	`100.0%`	`1/1`
`IsStrBlank(...)`	`github.com/wfusion/gofusion/common/utils/string.go`	`100.0%`	`1/1`
`@12:30(...)`	`github.com/wfusion/gofusion/common/utils/string.go`	`100.0%`	`1/1`
`IsStrNotBlank(...)`	`github.com/wfusion/gofusion/common/utils/string.go`	`100.0%`	`1/1`
`CryptoRandom(...)`	`github.com/wfusion/gofusion/common/utils/random.go`	`100.0%`	`1/1`
`ULID(...)`	`github.com/wfusion/gofusion/common/utils/random.go`	`100.0%`	`1/1`
`ShortUUID(...)`	`github.com/wfusion/gofusion/common/utils/random.go`	`100.0%`	`1/1`
`UUID(...)`	`github.com/wfusion/gofusion/common/utils/random.go`	`100.0%`	`1/1`
`SkipRegexps(...)`	`github.com/wfusion/gofusion/common/utils/func.go`	`100.0%`	`1/1`
`AnyPtr(...)`	`github.com/wfusion/gofusion/common/utils/conv.go`	`100.0%`	`1/1`
`SkipGlobs(...)`	`github.com/wfusion/gofusion/common/utils/func.go`	`100.0%`	`1/1`
`IsStrPtrNotBlank(...)`	`github.com/wfusion/gofusion/common/utils/string.go`	`100.0%`	`1/1`
`SkipKnownDepth(...)`	`github.com/wfusion/gofusion/common/utils/func.go`	`100.0%`	`1/1`
`@198:9(...)`	`github.com/wfusion/gofusion/common/utils/func.go`	`100.0%`	`1/1`
`@40:36(...)`	`github.com/wfusion/gofusion/common/utils/string.go`	`100.0%`	`1/1`
`poolBytesEvict(...)`	`github.com/wfusion/gofusion/common/utils/pool.go`	`100.0%`	`1/1`
`poolBytesBufferEvict(...)`	`github.com/wfusion/gofusion/common/utils/pool.go`	`100.0%`	`1/1`
`SetCtxAny(...)`	`github.com/wfusion/gofusion/common/utils/context.go`	`100.0%`	`1/1`
`poolSealer[T].Put(...)`	`github.com/wfusion/gofusion/common/utils/pool.go`	`100.0%`	`1/1`
`@41:36(...)`	`github.com/wfusion/gofusion/common/utils/string.go`	`100.0%`	`1/1`
`@88:14(...)`	`github.com/wfusion/gofusion/common/utils/pool.go`	`100.0%`	`1/1`
`@53:9(...)`	`github.com/wfusion/gofusion/common/utils/pool.go`	`100.0%`	`1/1`
`init(...)`	`github.com/wfusion/gofusion/common/utils/string.go`	`100.0%`	`1/1`
`@35:9(...)`	`github.com/wfusion/gofusion/common/utils/pool.go`	`100.0%`	`1/1`
`PoolableEvictFunc(...)`	`github.com/wfusion/gofusion/common/utils/pool.go`	`100.0%`	`1/1`
`ParseTagName(...)`	`github.com/wfusion/gofusion/common/utils/tag.go`	`100.0%`	`1/1`
`@16:3(...)`	`github.com/wfusion/gofusion/common/utils/pool.go`	`100.0%`	`1/1`
`@14:9(...)`	`github.com/wfusion/gofusion/common/utils/tag.go`	`100.0%`	`1/1`
`ParseTagUnmarshalType(...)`	`github.com/wfusion/gofusion/common/utils/tag.go`	`100.0%`	`1/1`
`@26:9(...)`	`github.com/wfusion/gofusion/common/utils/tag.go`	`100.0%`	`1/1`
`localIP.String(...)`	`github.com/wfusion/gofusion/common/utils/ip.go`	`100.0%`	`1/1`
`NextJitterIntervalFunc(...)`	`github.com/wfusion/gofusion/common/utils/time.go`	`100.0%`	`1/1`
`TimeoutWg(...)`	`github.com/wfusion/gofusion/common/utils/time.go`	`100.0%`	`1/1`
`@151:9(...)`	`github.com/wfusion/gofusion/common/utils/time.go`	`100.0%`	`1/1`
`@20:3(...)`	`github.com/wfusion/gofusion/common/utils/pool.go`	`100.0%`	`1/1`
`TraverseValue(...)`	`github.com/wfusion/gofusion/common/utils/reflect.go`	`93.3%`	`28/30`
`@60:9(...)`	`github.com/wfusion/gofusion/common/utils/ip.go`	`92.9%`	`13/14`
`@152:28(...)`	`github.com/wfusion/gofusion/common/utils/reflect.go`	`90.0%`	`9/10`
`EmbedsType(...)`	`github.com/wfusion/gofusion/common/utils/reflect.go`	`88.9%`	`16/18`
`runVariadicFunc(...)`	`github.com/wfusion/gofusion/common/utils/func.go`	`87.5%`	`21/24`
`Timeout(...)`	`github.com/wfusion/gofusion/common/utils/time.go`	`87.5%`	`7/8`
`Min(...)`	`github.com/wfusion/gofusion/common/utils/compare.go`	`85.7%`	`6/7`
`@11:8(...)`	`github.com/wfusion/gofusion/common/utils/candy.go`	`85.7%`	`6/7`
`newBuiltinLockedSource(...)`	`github.com/wfusion/gofusion/common/utils/random.go`	`85.7%`	`6/7`
`MapKeys(...)`	`github.com/wfusion/gofusion/common/utils/map.go`	`83.3%`	`5/6`
`IndirectType(...)`	`github.com/wfusion/gofusion/common/utils/reflect.go`	`83.3%`	`5/6`
`IndirectValue(...)`	`github.com/wfusion/gofusion/common/utils/reflect.go`	`83.3%`	`5/6`
`MapValues(...)`	`github.com/wfusion/gofusion/common/utils/map.go`	`83.3%`	`5/6`
`ComparableToSortable(...)`	`github.com/wfusion/gofusion/common/utils/conv.go`	`83.3%`	`5/6`
`.String(...)`	`github.com/wfusion/gofusion/common/utils/enum.go`	`80.0%`	`8/10`
`localIP.Bytes(...)`	`github.com/wfusion/gofusion/common/utils/ip.go`	`80.0%`	`4/5`
`ParseVariadicFuncResult(...)`	`github.com/wfusion/gofusion/common/utils/func.go`	`77.8%`	`7/9`
`MapValuesByKeys(...)`	`github.com/wfusion/gofusion/common/utils/map.go`	`77.8%`	`7/9`
`IsBlank(...)`	`github.com/wfusion/gofusion/common/utils/reflect.go`	`76.9%`	`10/13`
`@34:29(...)`	`github.com/wfusion/gofusion/common/utils/tag.go`	`76.9%`	`10/13`
`poolSealer[T].Get(...)`	`github.com/wfusion/gofusion/common/utils/pool.go`	`75.0%`	`9/12`
`Catch(...)`	`github.com/wfusion/gofusion/common/utils/candy.go`	`75.0%`	`9/12`
`ClientIP(...)`	`github.com/wfusion/gofusion/common/utils/ip.go`	`75.0%`	`6/8`
`CheckIfAny(...)`	`github.com/wfusion/gofusion/common/utils/candy.go`	`75.0%`	`3/4`
`NewEnumString(...)`	`github.com/wfusion/gofusion/common/utils/enum.go`	`75.0%`	`3/4`
`Max(...)`	`github.com/wfusion/gofusion/common/utils/compare.go`	`71.4%`	`5/7`
`TravelCtx(...)`	`github.com/wfusion/gofusion/common/utils/context.go`	`71.4%`	`5/7`
`SliceConvert(...)`	`github.com/wfusion/gofusion/common/utils/conv.go`	`68.2%`	`15/22`
`IsChannelClosed(...)`	`github.com/wfusion/gofusion/common/utils/channel.go`	`66.7%`	`4/6`
`CloseAnyway(...)`	`github.com/wfusion/gofusion/common/utils/candy.go`	`66.7%`	`4/6`
`Must(...)`	`github.com/wfusion/gofusion/common/utils/candy.go`	`66.7%`	`2/3`
`.caseSensitivityConv(...)`	`github.com/wfusion/gofusion/common/utils/enum.go`	`66.7%`	`2/3`
`GetTimeStamp(...)`	`github.com/wfusion/gofusion/common/utils/time.go`	`66.7%`	`2/3`
`FlushAnyway(...)`	`github.com/wfusion/gofusion/common/utils/candy.go`	`60.0%`	`3/5`
`Unmarshal(...)`	`github.com/wfusion/gofusion/common/utils/marshal.go`	`50.0%`	`11/22`
`MustSuccess(...)`	`github.com/wfusion/gofusion/common/utils/candy.go`	`50.0%`	`1/2`
`HostIPInDocker(...)`	`github.com/wfusion/gofusion/common/utils/ip.go`	`42.9%`	`3/7`
`SortableToGeneric(...)`	`github.com/wfusion/gofusion/common/utils/conv.go`	`7.1%`	`2/28`
`LoopWithInterval(...)`	`github.com/wfusion/gofusion/common/utils/time.go`	`0.0%`	`0/22`
`Set[T].Equals(...)`	`github.com/wfusion/gofusion/common/utils/sets.go`	`0.0%`	`0/13`
`Set[T].IntersectsWith(...)`	`github.com/wfusion/gofusion/common/utils/sets.go`	`0.0%`	`0/12`
`@132:28(...)`	`github.com/wfusion/gofusion/common/utils/reflect.go`	`0.0%`	`0/10`
`@94:28(...)`	`github.com/wfusion/gofusion/common/utils/reflect.go`	`0.0%`	`0/10`
`@114:28(...)`	`github.com/wfusion/gofusion/common/utils/reflect.go`	`0.0%`	`0/9`
`@100:9(...)`	`github.com/wfusion/gofusion/common/utils/func.go`	`0.0%`	`0/9`
`Set[T].IsSubsetOf(...)`	`github.com/wfusion/gofusion/common/utils/sets.go`	`0.0%`	`0/8`
`@87:9(...)`	`github.com/wfusion/gofusion/common/utils/func.go`	`0.0%`	`0/8`
`CryptoRandomLetterAndNumber(...)`	`github.com/wfusion/gofusion/common/utils/random.go`	`0.0%`	`0/7`
`CryptoRandomNumbers(...)`	`github.com/wfusion/gofusion/common/utils/random.go`	`0.0%`	`0/7`
`@75:9(...)`	`github.com/wfusion/gofusion/common/utils/func.go`	`0.0%`	`0/7`
`JsonStringify[T].UnmarshalJSON(...)`	`github.com/wfusion/gofusion/common/utils/marshal.go`	`0.0%`	`0/6`
`JsonStringify[T].MarshalJSON(...)`	`github.com/wfusion/gofusion/common/utils/marshal.go`	`0.0%`	`0/6`
`Set[T].Filter(...)`	`github.com/wfusion/gofusion/common/utils/sets.go`	`0.0%`	`0/6`
`@64:9(...)`	`github.com/wfusion/gofusion/common/utils/func.go`	`0.0%`	`0/6`
`Set[T].Reject(...)`	`github.com/wfusion/gofusion/common/utils/sets.go`	`0.0%`	`0/6`
`InvalidUnmarshalError.Error(...)`	`github.com/wfusion/gofusion/common/utils/marshal.go`	`0.0%`	`0/5`
`@54:9(...)`	`github.com/wfusion/gofusion/common/utils/time.go`	`0.0%`	`0/5`
`Heap[E].Copy(...)`	`github.com/wfusion/gofusion/common/utils/heap.go`	`0.0%`	`0/5`
`RandomNumbers(...)`	`github.com/wfusion/gofusion/common/utils/random.go`	`0.0%`	`0/5`
`@54:9(...)`	`github.com/wfusion/gofusion/common/utils/func.go`	`0.0%`	`0/5`
`@23:9(...)`	`github.com/wfusion/gofusion/common/utils/func.go`	`0.0%`	`0/5`
`MapSliceToMap(...)`	`github.com/wfusion/gofusion/common/utils/map.go`	`0.0%`	`0/5`
`DecimalPlaces(...)`	`github.com/wfusion/gofusion/common/utils/number.go`	`0.0%`	`0/4`
`CryptoRandomBytes(...)`	`github.com/wfusion/gofusion/common/utils/random.go`	`0.0%`	`0/4`
`UUID20(...)`	`github.com/wfusion/gofusion/common/utils/random.go`	`0.0%`	`0/4`
`SliceRemove(...)`	`github.com/wfusion/gofusion/common/utils/slice.go`	`0.0%`	`0/4`
`GetFieldByTagWithKeys(...)`	`github.com/wfusion/gofusion/common/utils/reflect.go`	`0.0%`	`0/3`
`NewHeap(...)`	`github.com/wfusion/gofusion/common/utils/heap.go`	`0.0%`	`0/3`
`Set[T].Size(...)`	`github.com/wfusion/gofusion/common/utils/sets.go`	`0.0%`	`0/3`
`Set[T].Clone(...)`	`github.com/wfusion/gofusion/common/utils/sets.go`	`0.0%`	`0/3`
`Heap[E].Element(...)`	`github.com/wfusion/gofusion/common/utils/heap.go`	`0.0%`	`0/3`
`IsInRange(...)`	`github.com/wfusion/gofusion/common/utils/compare.go`	`0.0%`	`0/3`
`MustOk(...)`	`github.com/wfusion/gofusion/common/utils/candy.go`	`0.0%`	`0/3`
`UUID22(...)`	`github.com/wfusion/gofusion/common/utils/random.go`	`0.0%`	`0/2`
`GetFieldTagValue(...)`	`github.com/wfusion/gofusion/common/utils/reflect.go`	`0.0%`	`0/2`
`IntNarrow(...)`	`github.com/wfusion/gofusion/common/utils/number.go`	`0.0%`	`0/2`
`GetFieldByTag(...)`	`github.com/wfusion/gofusion/common/utils/reflect.go`	`0.0%`	`0/2`
`@19:3(...)`	`github.com/wfusion/gofusion/common/utils/number.go`	`0.0%`	`0/2`
`@20:3(...)`	`github.com/wfusion/gofusion/common/utils/number.go`	`0.0%`	`0/2`
`@181:3(...)`	`github.com/wfusion/gofusion/common/utils/random.go`	`0.0%`	`0/2`
`@21:3(...)`	`github.com/wfusion/gofusion/common/utils/number.go`	`0.0%`	`0/2`
`@22:3(...)`	`github.com/wfusion/gofusion/common/utils/number.go`	`0.0%`	`0/2`
`@29:3(...)`	`github.com/wfusion/gofusion/common/utils/number.go`	`0.0%`	`0/2`
`IsValidTimestamp(...)`	`github.com/wfusion/gofusion/common/utils/time.go`	`0.0%`	`0/2`
`@30:3(...)`	`github.com/wfusion/gofusion/common/utils/number.go`	`0.0%`	`0/2`
`@31:3(...)`	`github.com/wfusion/gofusion/common/utils/number.go`	`0.0%`	`0/2`
`_heap[E].Pop(...)`	`github.com/wfusion/gofusion/common/utils/heap.go`	`0.0%`	`0/2`
`Sort(...)`	`github.com/wfusion/gofusion/common/utils/sort.go`	`0.0%`	`0/2`
`SortStable(...)`	`github.com/wfusion/gofusion/common/utils/sort.go`	`0.0%`	`0/2`
`_heap[E].Push(...)`	`github.com/wfusion/gofusion/common/utils/heap.go`	`0.0%`	`0/2`
`_heap[E].Less(...)`	`github.com/wfusion/gofusion/common/utils/heap.go`	`0.0%`	`0/2`
`@32:3(...)`	`github.com/wfusion/gofusion/common/utils/number.go`	`0.0%`	`0/2`
`UintNarrow(...)`	`github.com/wfusion/gofusion/common/utils/number.go`	`0.0%`	`0/2`
`UnsafeBytesToString(...)`	`github.com/wfusion/gofusion/common/utils/conv.go`	`0.0%`	`0/1`
`IsStrPtrBlank(...)`	`github.com/wfusion/gofusion/common/utils/string.go`	`0.0%`	`0/1`
`UnsafeStringToBytes(...)`	`github.com/wfusion/gofusion/common/utils/conv.go`	`0.0%`	`0/1`
`WrapFunc7(...)`	`github.com/wfusion/gofusion/common/utils/func.go`	`0.0%`	`0/1`
`UUID_(...)`	`github.com/wfusion/gofusion/common/utils/random.go`	`0.0%`	`0/1`
`sortable[E].Less(...)`	`github.com/wfusion/gofusion/common/utils/sort.go`	`0.0%`	`0/1`
`sortable[E].Swap(...)`	`github.com/wfusion/gofusion/common/utils/sort.go`	`0.0%`	`0/1`
`_heap[E].Swap(...)`	`github.com/wfusion/gofusion/common/utils/heap.go`	`0.0%`	`0/1`
`sortable[E].Len(...)`	`github.com/wfusion/gofusion/common/utils/sort.go`	`0.0%`	`0/1`
`@26:9(...)`	`github.com/wfusion/gofusion/common/utils/enum.go`	`0.0%`	`0/1`
`Heap[E].Push(...)`	`github.com/wfusion/gofusion/common/utils/heap.go`	`0.0%`	`0/1`
`ParseTagOverwrite(...)`	`github.com/wfusion/gofusion/common/utils/tag.go`	`0.0%`	`0/1`
`@20:9(...)`	`github.com/wfusion/gofusion/common/utils/tag.go`	`0.0%`	`0/1`
`Heap[E].Pop(...)`	`github.com/wfusion/gofusion/common/utils/heap.go`	`0.0%`	`0/1`
`Heap[E].Remove(...)`	`github.com/wfusion/gofusion/common/utils/heap.go`	`0.0%`	`0/1`
`Heap[E].Len(...)`	`github.com/wfusion/gofusion/common/utils/heap.go`	`0.0%`	`0/1`
`WrapFuncAny(...)`	`github.com/wfusion/gofusion/common/utils/func.go`	`0.0%`	`0/1`
`GetTime(...)`	`github.com/wfusion/gofusion/common/utils/time.go`	`0.0%`	`0/1`
`IgnoreEnumStringCase(...)`	`github.com/wfusion/gofusion/common/utils/enum.go`	`0.0%`	`0/1`
`WrapFunc6(...)`	`github.com/wfusion/gofusion/common/utils/func.go`	`0.0%`	`0/1`
`LoopJitterInterval(...)`	`github.com/wfusion/gofusion/common/utils/time.go`	`0.0%`	`0/1`
`WrapFunc5(...)`	`github.com/wfusion/gofusion/common/utils/func.go`	`0.0%`	`0/1`
`LoopMaxTimes(...)`	`github.com/wfusion/gofusion/common/utils/time.go`	`0.0%`	`0/1`
`@65:9(...)`	`github.com/wfusion/gofusion/common/utils/time.go`	`0.0%`	`0/1`
`NewSafeRand(...)`	`github.com/wfusion/gofusion/common/utils/random.go`	`0.0%`	`0/1`
`WrapFunc4(...)`	`github.com/wfusion/gofusion/common/utils/func.go`	`0.0%`	`0/1`
`@182:19(...)`	`github.com/wfusion/gofusion/common/utils/random.go`	`0.0%`	`0/1`
`WrapFunc3(...)`	`github.com/wfusion/gofusion/common/utils/func.go`	`0.0%`	`0/1`
`Error.Error(...)`	`github.com/wfusion/gofusion/common/utils/error.go`	`0.0%`	`0/1`
`MustJsonMarshalString(...)`	`github.com/wfusion/gofusion/common/utils/marshal.go`	`0.0%`	`0/1`
`_heap[E].Len(...)`	`github.com/wfusion/gofusion/common/utils/heap.go`	`0.0%`	`0/1`

func NginxID

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/random.go:

func NginxID() string {
        upper := func(c byte) byte {
                val := c
                if val >= 97 && val <= 122 {
                        return val - 32
                }
                return c
        }
        int2byte := func(bs []byte, val int) {
                size := 10
                l := len(bs) - 1
                for idx := l; idx >= 0; idx-- {
                        bs[idx] = byte(uint(val%size) + uint('0'))
                        val = val / size
                }
        }

        ret := [33]byte{}
        t := time.Now()
        year, month, day := t.Date()
        hour, minute, second := t.Clock()
        int2byte(ret[:4], year)
        int2byte(ret[4:6], int(month))
        int2byte(ret[6:8], day)
        int2byte(ret[8:10], hour)
        int2byte(ret[10:12], minute)
        int2byte(ret[12:14], second)
        copy(ret[14:26], LocalIP.Bytes())
        ms := t.UnixNano() / 1e6 % 1000
        int2byte(ret[26:29], int(ms))
        u32 := rand.Uint32()
        u32 >>= 16
        src := []byte{byte(u32 & 0xff), byte((u32 >> 8) & 0xff)}
        hex.Encode(ret[29:33], src)
        for idx := 29; idx < 33; idx++ {
                ret[idx] = upper(ret[idx])
        }
        return string(ret[:])
}

func GetCaller

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/func.go:

func GetCaller(maximumCallerDepth int, opts ...OptionExtender) (frame *runtime.Frame) {
        opt := ApplyOptions[getCallerOption](opts...)
        pcs := make([]uintptr, maximumCallerDepth)
        depth := runtime.Callers(opt.minimumCallerDepth, pcs)
        frames := runtime.CallersFrames(pcs[:depth])
outer:
        for f, hasMore := frames.Next(); hasMore; f, hasMore = frames.Next() {
                frame = &f

                // If the caller isn't part of this package, we're done
                for _, skipGlob := range opt.skipGlobList {
                        if skipGlob.Match(f.File) {
                                continue outer
                        }
                }
                for _, s := range opt.skipRegList {
                        if s.MatchString(f.File) {
                                continue outer
                        }
                }
                break
        }

        return
}

func .init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/enum.go:

func (e *enumString[T, TS]) init() Enumerable[T, TS] {
        // get key
        var key any
        for k := range e.mapping {
                key = k
                break
        }
        e.elemType = reflect.TypeOf(key)
        e.elemSliceType = reflect.SliceOf(e.elemType)

        // get prefix name
        e.prefix = cases.Title(language.English, cases.NoLower).String(e.elemType.Name())

        // get reversed mapping
        e.reversedMapping = make(map[string]TS, len(e.mapping))
        for k, v := range e.mapping {
                v = e.caseSensitivityConv(v)
                e.reversedMapping[v] = append(e.reversedMapping[v], k)
        }

        return e
}

func FuzzyKeyword

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/string.go:

func FuzzyKeyword(keyword string) []string {
        words := strings.Fields(constant.NonNumberLetterReg.ReplaceAllString(keyword, " "))
        compact := strings.Join(words, "")
        lowerWords := SliceMapping(words, func(s string) string { return strings.ToLower(s) })
        upperWords := SliceMapping(words, func(s string) string { return strings.ToUpper(s) })
        titleWords := SliceMapping(words, func(s string) string { return strings.Title(s) })

        s := NewSet(keyword)
        s.Insert(
                compact,
                strings.ToUpper(compact),
                strings.ToLower(compact),
                strcase.ToCamel(keyword),
                strcase.ToLowerCamel(keyword),
                strcase.ToKebab(keyword),
                strcase.ToSnake(keyword),
                strcase.ToScreamingSnake(keyword),
                strcase.ToScreamingKebab(keyword),
        )
        for _, delimited := range keywordFuzzyDelimited {
                s.Insert(
                        strings.Join(lowerWords, delimited),
                        strings.Join(upperWords, delimited),
                        strings.Join(titleWords, delimited),
                )
        }

        return s.Items()
}

func @117:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/time.go:

func() (interval time.Duration) {
                // add specified ratio jitter
                if !symmetric {
                        // if ratio is 0.5
                        // then interval = base + random(0.5*base) <=> [base, 1.5*base)
                        // if ratio is 0.1
                        // then interval = base + random(0.1*base) <=> [base, 1.1*base)
                        _range := float64(base) * ratio * rand.Float64()
                        interval = base + time.Duration(_range)
                } else {
                        // if ratio is 0.5
                        // then interval = base + random(0.5*base) - 0.25*base <=> [0.75*base, 1.25*base)
                        // if ratio is 0.1
                        // then interval = base + random(0.1*base) - 0.05*base <=> [0.95*base, 1.05*base)
                        _range := float64(base) * ratio * rand.Float64()
                        interval = base + time.Duration(_range) - time.Duration(float64(base)*(ratio/2))
                }

                // double and clamp for next time
                base = time.Duration(float64(base) * exp)
                if base > max {
                        base = max
                }
                return interval
        }

func Set[T].Items

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/sets.go:

func (s *Set[T]) Items() []T {
        s.m.RLock()
        defer s.m.RUnlock()

        i := 0
        ret := make([]T, len(s.storage))
        for key := range s.storage {
                ret[i] = key
                i++
        }
        return ret
}

func SliceMapping

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/conv.go:

func SliceMapping[T, K any](s []T, mapFn func(t T) K) (d []K) {
        if s == nil {
                return
        }
        d = make([]K, 0, len(s))
        for _, item := range s {
                d = append(d, mapFn(item))
        }
        return
}

func MapMerge

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/map.go:

40	`func MapMerge[T comparable, K any](a, b map[T]K) (r map[T]K) {`
41	`r = make(map[T]K, len(a)+len(b))`
42	`for k, v := range a {`
43	`r[k] = v`
44	`}`
45	`for k, v := range b {`
46	`r[k] = v`
47	`}`
48	`return`
49	`}`

func poolBytes.Reset

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/pool.go:

func (p poolBytes) Reset(initLen any) poolBytes {
        iLen := cast.ToInt(initLen)
        pp := p
        if cap(p) < cast.ToInt(iLen) {
                pp = make([]byte, iLen)
        }

        return pp[:iLen]
}

func Set[T].Remove

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/sets.go:

func (s *Set[T]) Remove(val ...T) *Set[T] {
        s.m.Lock()
        defer s.m.Unlock()

        for _, v := range val {
                delete(s.storage, v)
        }
        return s
}

func Set[T].Insert

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/sets.go:

func (s *Set[T]) Insert(val ...T) *Set[T] {
        s.m.Lock()
        defer s.m.Unlock()

        for _, v := range val {
                s.storage[v] = struct{}{}
        }
        return s
}

func ApplyOptions

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/options.go:

func ApplyOptions[T any](opts ...OptionExtender) (t *T) {
        t = new(T)
        for _, optional := range opts {
                if optional != nil {
                        optional.applyOption(t)
                }
        }
        return
}

func RandomLetterAndNumber

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/random.go:

func RandomLetterAndNumber(n int) string {
        random := make([]byte, 0, n)
        rand.Seed(time.Now().UnixNano())
        for i := 0; i < n; i++ {
                random = append(random, randomChars[rand.Intn(randomCharsLength)])
        }

        return string(random)
}

func @61:14

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/ip.go:

61	`func(bs []byte) {`
62	`i, j := 0, len(bs)-1`
63	`for i < j {`
64	`bs[i], bs[j] = bs[j], bs[i]`
65	`i++`
66	`j--`
67	`}`
68	`}`

func @133:14

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/random.go:

func(bs []byte, val int) {
                size := 10
                l := len(bs) - 1
                for idx := l; idx >= 0; idx-- {
                        bs[idx] = byte(uint(val%size) + uint('0'))
                        val = val / size
                }
        }

func GetCtxAny

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/context.go:

func GetCtxAny[T any](ctx context.Context, key string, args ...T) (val T) {
        if v := ctx.Value(key); v != nil {
                return v.(T)
        }
        if len(args) == 0 {
                return
        }
        return args[0]
}

func LookupByFuzzyKeyword

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/candy.go:

func LookupByFuzzyKeyword[T any, F lookupByFuzzyKeywordFuncType[T]](lookup F, keyword string) (v T) {
        fn := WrapFunc1[T](lookup)
        for _, k := range FuzzyKeyword(keyword) {
                if v = fn(k); !IsBlank(v) {
                        return
                }
        }
        return
}

func ParseTag

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/tag.go:

func ParseTag(data any, opts ...OptionExtender) (err error) {
        opt := ApplyOptions[parseTagOption](opts...)
        stepInKinds := NewSet(reflect.Struct, reflect.Array, reflect.Slice, reflect.Map)
        TraverseValue(data, false, func(field reflect.StructField, value reflect.Value) (end, stepIn bool) {
                if !value.IsValid() || !value.CanSet() || !value.CanAddr() || !value.CanInterface() {
                        return
                }

                vk := value.Kind()
                stepIn = stepInKinds.Contains(vk) ||
                        (vk == reflect.Ptr && value.Elem().IsValid() && value.Elem().Kind() == reflect.Struct)

                defaultString := field.Tag.Get(opt.tag)
                if IsStrBlank(defaultString) || (!opt.overwrite && !IsBlank(value)) {
                        return
                }

                defaultValue := reflect.New(value.Type()).Interface()
                if err = Unmarshal(defaultString, defaultValue, opt.unmarshalType); err != nil {
                        end = true
                        return
                }
                value.Set(reflect.ValueOf(defaultValue).Elem())
                return
        })

        return
}

func .Enum

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/enum.go:

func (e *enumString[T, TS]) Enum(s string) TS {
        s = e.caseSensitivityConv(s)
        if v, ok := e.reversedMapping[s]; ok {
                return SliceConvert(v, e.elemSliceType).(TS)
        }
        return nil
}

func NewSet

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/sets.go:

func NewSet[T comparable](arr ...T) (s *Set[T]) {
        s = &Set[T]{
                m:       new(sync.RWMutex),
                storage: make(map[T]struct{}, len(arr)),
        }
        for _, item := range arr {
                s.storage[item] = struct{}{}
        }
        return
}

func SliceToMap

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/map.go:

func SliceToMap[K comparable, V any](s []V, groupFn func(v V) K) (d map[K]V) {
        d = make(map[K]V)
        for _, i := range s {
                d[groupFn(i)] = i
        }
        return
}

func @45:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/func.go:

func(a ...any) (t1 T1, t2 T2) {
                ret := runVariadicFunc(fn, a...)
                t1 = ParseVariadicFuncResult[T1](ret, 0)
                t2 = ParseVariadicFuncResult[T2](ret, 1)
                return
        }

func Set[T].Contains

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/sets.go:

func (s *Set[T]) Contains(val T) bool {
        s.m.RLock()
        defer s.m.RUnlock()

        _, ok := s.storage[val]
        return ok
}

func Random

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/random.go:

func Random(b []byte, seed int64) (n int, err error) {
        if seed == 0 {
                rand.Seed(time.Now().UnixNano())
        } else {
                rand.Seed(seed)
        }
        return rand.Read(b)
}

func ErrIgnore

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/candy.go:

func ErrIgnore(src error, ignored ...error) (dst error) {
        for _, target := range ignored {
                if errors.Is(src, target) {
                        return
                }
        }
        return src
}

func @126:11

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/random.go:

func(c byte) byte {
                val := c
                if val >= 97 && val <= 122 {
                        return val - 32
                }
                return c
        }

func SliceReverse

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/slice.go:

12	`func SliceReverse[T any, TS ~[]T](s TS) {`
13	`for i := len(s)/2 - 1; i >= 0; i-- {`
14	`opp := len(s) - 1 - i`
15	`s[i], s[opp] = s[opp], s[i]`
16	`}`
17	`}`

func IfAny

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/candy.go:

func IfAny(fnList ...func() bool) {
        for _, fn := range fnList {
                if fn() {
                        break
                }
        }
}

func GetGormColumnValue

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/reflect.go:

func GetGormColumnValue(data any, column string) (columnVal reflect.Value, ok bool) {
        tagKey := strings.ToUpper(column)
        TraverseValue(data, true, func(field reflect.StructField, value reflect.Value) (end, stepIn bool) {
                if !value.IsValid() {
                        return false, false
                }
                if value.Type().Kind() == reflect.Struct {
                        return false, true
                }
                tagSetting := schema.ParseTagSetting(field.Tag.Get("gorm"), ";")
                if _, ok := tagSetting[tagKey]; ok || tagSetting["COLUMN"] == column {
                        columnVal = value
                        end = true
                        return
                }
                return
        })
        return
}

func @159:5

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/time.go:

func() {
                switch {
                case opt.wg != nil:
                        opt.wg.Wait()
                }
                wgClosed <- struct{}{}
        }

func @89:11

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/pool.go:

func() {
                        if p.option.evict == nil || !p.option.evict(obj) {
                                p.Put(obj)
                        }
                }

func .IsValid

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/enum.go:

79	`func (e *enumString[T, TS]) IsValid(t T) bool {`
80	`_, ok := e.mapping[t]`
81	`return ok`
82	`}`

func OptionFunc[T].applyOption

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/options.go:

9	`func (o OptionFunc[T]) applyOption(a any) {`
10	`if t, ok := a.(*T); ok {`
11	`o(t)`
12	`}`
13	`}`

func @182:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/func.go:

func(o *getCallerOption) {
                for _, pattern := range patterns {
                        o.skipRegList = append(o.skipRegList, regexp.MustCompile(pattern))
                }
        }

func MustJsonUnmarshal

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/marshal.go:

43	`func MustJsonUnmarshal[T any](s []byte) (t *T) { MustSuccess(json.Unmarshal(s, &t)); return }`

func @176:3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/random.go:

176	`func() bool {`
177	`_, err = Catch(func() { inspect.SetField(source, "src", rand.NewSource(seed)) })`
178	`return err == nil`
179	`}`

func init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/random.go:

func init() {
        rand.Seed(time.Now().Unix())

        // assert if rand.lockedSource struct is not changed
        newBuiltinLockedSource(1).Int63()
}

func @190:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/func.go:

func(o *getCallerOption) {
                for _, pattern := range patterns {
                        o.skipGlobList = append(o.skipGlobList, glob.MustCompile(pattern))
                }
        }

func NewPool

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/pool.go:

func NewPool[T any](newFn func() T, opts ...OptionExtender) Poolable[T] {
        opt := ApplyOptions[poolableOption[T]](opts...)
        return &poolSealer[T]{
                option: opt,
                newFn:  newFn,
                inner: &sync.Pool{
                        New: func() any {
                                return any(newFn())
                        },
                },
        }
}

func @34:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/func.go:

34	`func(a ...any) (t T) {`
35	`ret := runVariadicFunc(fn, a...)`
36	`return ParseVariadicFuncResult[T](ret, 0)`
37	`}`

func WrapFunc2

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/func.go:

func WrapFunc2[T1, T2 any](fn any) func(...any) (T1, T2) {
        return func(a ...any) (t1 T1, t2 T2) {
                ret := runVariadicFunc(fn, a...)
                t1 = ParseVariadicFuncResult[T1](ret, 0)
                t2 = ParseVariadicFuncResult[T2](ret, 1)
                return
        }
}

func WrapFunc1

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/func.go:

func WrapFunc1[T any](fn any) func(...any) T {
        return func(a ...any) (t T) {
                ret := runVariadicFunc(fn, a...)
                return ParseVariadicFuncResult[T](ret, 0)
        }
}

func @39:36

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/string.go:

39	`func(s string) string { return strings.ToLower(s) }`

func MustJsonMarshal

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/marshal.go:

41	`func MustJsonMarshal(s any) []byte { return Must(json.Marshal(s)) }`

func @17:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/func.go:

17	`func(a ...any) {`
18	`runVariadicFunc(fn, a...)`
19	`}`

func @177:19

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/random.go:

177	`func() { inspect.SetField(source, "src", rand.NewSource(seed)) }`

func WrapFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/func.go:

func WrapFunc(fn any) func(...any) {
        return func(a ...any) {
                runVariadicFunc(fn, a...)
        }
}

func GetFuncName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/func.go:

12	`func GetFuncName(fn any) string {`
13	`return runtime.FuncForPC(reflect.ValueOf(fn).Pointer()).Name()`
14	`}`

func IsStrBlank

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/string.go:

11	`func IsStrBlank(s string) bool {`
12	`return strings.IndexFunc(s, func(r rune) bool { return !(unicode.IsSpace(r)) }) < 0`
13	`}`

func @12:30

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/string.go:

12	`func(r rune) bool { return !(unicode.IsSpace(r)) }`

func IsStrNotBlank

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/string.go:

19	`func IsStrNotBlank(s string) bool {`
20	`return !IsStrBlank(s)`
21	`}`

func CryptoRandom

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/random.go:

59	`func CryptoRandom(b []byte) (n int, err error) {`
60	`return cryptoRand.Read(b)`
61	`}`

func ULID

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/random.go:

38	`func ULID() string {`
39	`return ulid.MustNew(ulid.Now(), cryptoRand.Reader).String()`
40	`}`

func ShortUUID

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/random.go:

33	`func ShortUUID() string {`
34	`return shortuuid.New()`
35	`}`

func UUID

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/random.go:

22	`func UUID() string {`
23	`return uuid.New().String()`
24	`}`

func SkipRegexps

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/func.go:

func SkipRegexps(patterns ...string) OptionFunc[getCallerOption] {
        return func(o *getCallerOption) {
                for _, pattern := range patterns {
                        o.skipRegList = append(o.skipRegList, regexp.MustCompile(pattern))
                }
        }
}

func AnyPtr

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/conv.go:

145	`func AnyPtr[T any](s T) *T { return &s }`

func SkipGlobs

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/func.go:

func SkipGlobs(patterns ...string) OptionFunc[getCallerOption] {
        return func(o *getCallerOption) {
                for _, pattern := range patterns {
                        o.skipGlobList = append(o.skipGlobList, glob.MustCompile(pattern))
                }
        }
}

func IsStrPtrNotBlank

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/string.go:

23	`func IsStrPtrNotBlank(s *string) bool {`
24	`return s != nil && IsStrNotBlank(*s)`
25	`}`

func SkipKnownDepth

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/func.go:

func SkipKnownDepth(minimumCallerDepth int) OptionFunc[getCallerOption] {
        return func(o *getCallerOption) {
                o.minimumCallerDepth = minimumCallerDepth
        }
}

func @198:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/func.go:

198	`func(o *getCallerOption) {`
199	`o.minimumCallerDepth = minimumCallerDepth`
200	`}`

func @40:36

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/string.go:

40	`func(s string) string { return strings.ToUpper(s) }`

func poolBytesEvict

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/pool.go:

115	`func poolBytesEvict(p poolBytes) bool {`
116	`return cap(p) >= maxBytesPoolable`
117	`}`

func poolBytesBufferEvict

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/pool.go:

111	`func poolBytesBufferEvict(b *bytes.Buffer) bool {`
112	`return b.Cap() >= maxBytesPoolable`
113	`}`

func SetCtxAny

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/context.go:

20	`func SetCtxAny[T any](ctx context.Context, key string, val T) context.Context {`
21	`return context.WithValue(ctx, key, val)`
22	`}`

func poolSealer[T].Put

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/pool.go:

97	`func (p *poolSealer[T]) Put(obj T) { p.inner.Put(obj) }`

func @41:36

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/string.go:

41	`func(s string) string { return strings.Title(s) }`

func @88:14

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/pool.go:

func() {
                once.Do(func() {
                        if p.option.evict == nil || !p.option.evict(obj) {
                                p.Put(obj)
                        }
                })
        }

func @53:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/pool.go:

53	`func() any {`
54	`return any(newFn())`
55	`}`

func init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/string.go:

66	`func init() {`
67	`strcase.ConfigureAcronym("I18n", "i18n")`
68	`}`

func @35:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/pool.go:

35	`func(o *poolableOption[T]) {`
36	`o.evict = fn`
37	`}`

func PoolableEvictFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/pool.go:

func PoolableEvictFunc[T any](fn func(obj T) bool) OptionFunc[poolableOption[T]] {
        return func(o *poolableOption[T]) {
                o.evict = fn
        }
}

func ParseTagName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/tag.go:

func ParseTagName(tag string) OptionFunc[parseTagOption] {
        return func(o *parseTagOption) {
                o.tag = tag
        }
}

func @16:3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/pool.go:

16	`func() *bytes.Buffer { return bytes.NewBuffer(make([]byte, 0, 64)) }`

func @14:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/tag.go:

14	`func(o *parseTagOption) {`
15	`o.tag = tag`
16	`}`

func ParseTagUnmarshalType

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/tag.go:

func ParseTagUnmarshalType(unmarshalTag unmarshalType) OptionFunc[parseTagOption] {
        return func(o *parseTagOption) {
                o.unmarshalType = unmarshalTag
        }
}

func @26:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/tag.go:

26	`func(o *parseTagOption) {`
27	`o.unmarshalType = unmarshalTag`
28	`}`

func localIP.String

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/ip.go:

54	`func (l *localIP) String() string {`
55	`return l.str`
56	`}`

func NextJitterIntervalFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/time.go:

func NextJitterIntervalFunc(base, max time.Duration, ratio, exp float64, symmetric bool) func() time.Duration {
        return func() (interval time.Duration) {
                // add specified ratio jitter
                if !symmetric {
                        // if ratio is 0.5
                        // then interval = base + random(0.5*base) <=> [base, 1.5*base)
                        // if ratio is 0.1
                        // then interval = base + random(0.1*base) <=> [base, 1.1*base)
                        _range := float64(base) * ratio * rand.Float64()
                        interval = base + time.Duration(_range)
                } else {
                        // if ratio is 0.5
                        // then interval = base + random(0.5*base) - 0.25*base <=> [0.75*base, 1.25*base)
                        // if ratio is 0.1
                        // then interval = base + random(0.1*base) - 0.05*base <=> [0.95*base, 1.05*base)
                        _range := float64(base) * ratio * rand.Float64()
                        interval = base + time.Duration(_range) - time.Duration(float64(base)*(ratio/2))
                }

                // double and clamp for next time
                base = time.Duration(float64(base) * exp)
                if base > max {
                        base = max
                }
                return interval
        }
}

func TimeoutWg

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/time.go:

func TimeoutWg(wg *sync.WaitGroup) OptionFunc[timeoutOption] {
        return func(o *timeoutOption) {
                o.wg = wg
        }
}

func @151:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/time.go:

151	`func(o *timeoutOption) {`
152	`o.wg = wg`
153	`}`

func @20:3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/pool.go:

20	`func() poolBytes { return make([]byte, 0, 64) }`

func TraverseValue

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/reflect.go:

func TraverseValue(data any, indirect bool, handler func(reflect.StructField, reflect.Value) (end, stepIn bool)) {
        v, ok := data.(reflect.Value)
        if !ok {
                v = reflect.ValueOf(data)
        }
        v = IndirectValue(v)
        l := list.New()
        l.PushBack(v)
TraverseStruct:
        for l.Len() > 0 {
                e := IndirectValue(l.Remove(l.Front()).(reflect.Value))
                if !e.IsValid() {
                        continue
                }
                t := IndirectType(e.Type())
                switch e.Kind() {
                case reflect.Array, reflect.Slice:
                        for i, num := 0, e.Len(); i < num; i++ {
                                l.PushBack(e.Index(i))
                        }
                case reflect.Map:
                        for iter := e.MapRange(); iter.Next(); {
                                l.PushBack(iter.Key())
                                l.PushBack(iter.Value())
                        }
                case reflect.Struct:
                        for i, num := 0, e.NumField(); i < num; i++ {
                                ff := t.Field(i)
                                fv := e.Field(i)
                                if !fv.IsValid() {
                                        continue
                                }
                                if indirect {
                                        fv = IndirectValue(fv)
                                        ff.Type = IndirectType(ff.Type)
                                }
                                end, stepIn := handler(ff, fv)
                                if end {
                                        break TraverseStruct
                                }
                                if stepIn {
                                        l.PushBack(fv)
                                }
                        }
                default:
                        // do nothing
                }
        }
}

func @60:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/ip.go:

60	`func() []byte {`
61	`reverse := func(bs []byte) {`
62	`i, j := 0, len(bs)-1`
63	`for i < j {`
64	`bs[i], bs[j] = bs[j], bs[i]`
65	`i++`
66	`j--`
67	`}`
68	`}`
69
70	`if ipAddr := ClientIP(); ipAddr != "" {`
71	`realIP := []byte("000000000000")`
72	`idx := 0`
73	`for i := len(ipAddr) - 1; i >= 0; i-- {`
74	`c := ipAddr[i]`
75	`if c == '.' {`
76	`idx = (((idx - 1) / 3) + 1) * 3`
77	`continue`
78	`}`
79	`realIP[idx] = c`
80	`idx++`
81	`}`
82	`reverse(realIP)`
83	`return realIP`
84	`}`
85	`return []byte("000000000000")`
86	`}`

func @152:28

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/reflect.go:

func(field reflect.StructField, value reflect.Value) (end, stepIn bool) {
                if !value.IsValid() {
                        return false, false
                }
                if value.Type().Kind() == reflect.Struct {
                        return false, true
                }
                tagSetting := schema.ParseTagSetting(field.Tag.Get("gorm"), ";")
                if _, ok := tagSetting[tagKey]; ok || tagSetting["COLUMN"] == column {
                        columnVal = value
                        end = true
                        return
                }
                return
        }

func EmbedsType

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/reflect.go:

func EmbedsType(i any, e reflect.Type) bool {
        // given `type A foo { *In }`, this function would return false for
        // embedding dig.In, which makes for some extra error checking in places
        // that call this function. Might be worthwhile to consider reflect.Indirect
        // usage to clean up the callers.

        if i == nil {
                return false
        }

        // maybe it's already a reflect.Type
        t, ok := i.(reflect.Type)
        if !ok {
                // take the type if it's not
                t = IndirectType(reflect.TypeOf(i))
        }

        // We are going to do a breadth-first search of all embedded fields.
        types := list.New()
        types.PushBack(t)
        for types.Len() > 0 {
                t := types.Remove(types.Front()).(reflect.Type)

                if t == e {
                        return true
                }

                if t.Kind() != reflect.Struct {
                        continue
                }

                for i := 0; i < t.NumField(); i++ {
                        f := t.Field(i)
                        if f.Anonymous {
                                types.PushBack(f.Type)
                        }
                }
        }

        return false
}

func runVariadicFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/func.go:

func runVariadicFunc(fn any, a ...any) []reflect.Value {
        var (
                variadic   []reflect.Value
                typ        = reflect.TypeOf(fn)
                val        = reflect.ValueOf(fn)
                numIn      = typ.NumIn()
                isVariadic = typ.IsVariadic()
        )

        if isVariadic {
                b := a[numIn-1:]
                bt := typ.In(numIn - 1).Elem()
                variadic = make([]reflect.Value, 0, len(b))
                for _, param := range b {
                        paramVal := reflect.ValueOf(param)
                        if paramVal.CanConvert(bt) {
                                variadic = append(variadic, paramVal.Convert(bt))
                        } else {
                                bo := reflect.New(bt).Elem().Interface()
                                MustSuccess(mapstructure.Decode(param, &bo))
                                variadic = append(variadic, reflect.ValueOf(bo))
                        }
                }
                a = a[:numIn-1]
        }

        in := make([]reflect.Value, 0, len(a)+len(variadic))
        for idx, param := range a {
                pt := typ.In(idx)
                paramVal := reflect.ValueOf(param)
                if paramVal.CanConvert(pt) {
                        in = append(in, paramVal.Convert(pt))
                } else {
                        po := reflect.New(pt).Elem().Interface()
                        MustSuccess(mapstructure.Decode(param, &po))
                        in = append(in, reflect.ValueOf(po))
                }
        }
        in = append(in, variadic...)

        return val.Call(in)
}

func Timeout

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/time.go:

func Timeout(timeout time.Duration, opts ...OptionExtender) bool {
        opt := ApplyOptions[timeoutOption](opts...)
        wgClosed := make(chan struct{}, 1)
        go func() {
                switch {
                case opt.wg != nil:
                        opt.wg.Wait()
                }
                wgClosed <- struct{}{}
        }()

        timer := time.NewTimer(timeout)
        defer timer.Stop()
        select {
        case <-wgClosed:
                return false
        case <-timer.C:
                return true
        }
}

func Min

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compare.go:

func Min[T constraint.Sortable](arr ...T) T {
        if len(arr) == 0 {
                panic(ErrEmptyArray)
        }

        min := arr[0]
        for i := 1; i < len(arr); i++ {
                if arr[i] < min {
                        min = arr[i]
                }
        }

        return min
}

func @11:8

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/candy.go:

func() {
                r := recover()
                if r == nil {
                        return
                }

                isPanic = true
                switch v := r.(type) {
                case error:
                        err = errors.Wrapf(v, "panic when call Catch function =>\n%s", debug.Stack())
                default:
                        err = errors.Errorf("panic when call Catch function: %s =>\n%s", r, debug.Stack())
                }
        }

func newBuiltinLockedSource

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/random.go:

func newBuiltinLockedSource(seed int64) rand.Source64 {
        t := inspect.TypeOf("math/rand.lockedSource")
        source := reflect.New(t).Interface()

        var err error
        IfAny(
                // go1.16 - go1.19
                func() bool {
                        _, err = Catch(func() { inspect.SetField(source, "src", rand.NewSource(seed)) })
                        return err == nil
                },
                // go1.20 - go1.21, source is renamed and set seed when calling rather than constructing stage
                func() bool {
                        _, err = Catch(func() { inspect.SetField(source, "s", rand.NewSource(seed)) })
                        return err == nil
                },
        )
        if err != nil {
                panic(err)
        }

        return source.(rand.Source64)
}

func MapKeys

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/map.go:

func MapKeys[T comparable, K any](m map[T]K) (keys []T) {
        if m == nil {
                return
        }
        keys = make([]T, 0, len(m))
        for key := range m {
                keys = append(keys, key)
        }
        return
}

func IndirectType

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/reflect.go:

func IndirectType(s reflect.Type) (d reflect.Type) {
        if s == nil {
                return s
        }
        d = s
        for d.Kind() == reflect.Ptr {
                d = d.Elem()
        }
        return
}

func IndirectValue

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/reflect.go:

func IndirectValue(s reflect.Value) (d reflect.Value) {
        if !s.IsValid() {
                return s
        }
        d = s
        for d.Kind() == reflect.Ptr {
                d = d.Elem()
        }
        return
}

func MapValues

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/map.go:

func MapValues[T comparable, K any](m map[T]K) (vals []K) {
        if m == nil {
                return
        }
        vals = make([]K, 0, len(m))
        for _, val := range m {
                vals = append(vals, val)
        }
        return
}

func ComparableToSortable

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/conv.go:

func ComparableToSortable[T comparable](s T) (d any) {
        val := reflect.ValueOf(s)
        typ := val.Type()
        for _, sortableType := range sortableReflectType {
                if typ.ConvertibleTo(sortableType) {
                        return val.Convert(sortableType).Interface()
                }
        }

        return
}

func .String

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/enum.go:

func (e *enumString[T, TS]) String(k any) string {
        if reflect.TypeOf(k).ConvertibleTo(e.elemType) {
                k = reflect.ValueOf(k).Convert(e.elemType).Interface().(T)
        }
        if t, ok := k.(T); !ok {
                return fmt.Sprintf("%s(%v)", e.prefix, k)
        } else {
                if v, ok := e.mapping[t]; ok {
                        return v
                }
                // avoid stack overflow for Stringer implement
                sortable := ComparableToSortable(t)
                if sortable != nil {
                        return fmt.Sprintf("%s(%+v)", e.prefix, sortable)
                } else {
                        return fmt.Sprintf("%s(N/A)", e.prefix)
                }
        }
}

func localIP.Bytes

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/ip.go:

func (l *localIP) Bytes() (d []byte) {
        if l.bytes == nil {
                return
        }
        d = make([]byte, len(l.bytes), cap(l.bytes))
        copy(d, l.bytes)
        return
}

func ParseVariadicFuncResult

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/func.go:

func ParseVariadicFuncResult[T any](rs []reflect.Value, idx int) (t T) {
        var (
                ok  bool
                typ = reflect.TypeOf(t)
        )
        for i := idx; i < len(rs); i++ {
                r := rs[i]
                if !r.IsValid() || r.Type() == nil {
                        continue
                }
                if v := r.Interface(); v != nil {
                        if t, ok = v.(T); !ok && typ != nil && reflect.TypeOf(v).ConvertibleTo(typ) {
                                t = r.Convert(typ).Interface().(T)
                        }
                }
        }
        return
}

func MapValuesByKeys

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/map.go:

func MapValuesByKeys[T comparable, K any, TS ~[]T](m map[T]K, keys TS) (vals []K) {
        if m == nil {
                return
        }
        vals = make([]K, 0, len(keys))
        for _, key := range keys {
                val, ok := m[key]
                if !ok {
                        continue
                }
                vals = append(vals, val)
        }
        return
}

func IsBlank

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/reflect.go:

func IsBlank(object any) bool {
        // get nil case out of the way
        if object == nil {
                return true
        }

        objVal, ok := object.(reflect.Value)
        if !ok {
                objVal = reflect.ValueOf(object)
        }
        switch objVal.Kind() {
        // collection types are empty when they have no element
        case reflect.Chan, reflect.Map, reflect.Slice:
                return objVal.Len() == 0
        // pointers are empty if nil or if the value they point to is empty
        case reflect.Ptr:
                if objVal.IsNil() {
                        return true
                }
                deref := objVal.Elem().Interface()
                return IsBlank(deref)
        // for all other types, compare against the zero value
        // array types are empty when they match their zero-initialized state
        default:
                zero := reflect.Zero(objVal.Type())
                return reflect.DeepEqual(objVal.Interface(), zero.Interface())
        }
}

func @34:29

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/tag.go:

func(field reflect.StructField, value reflect.Value) (end, stepIn bool) {
                if !value.IsValid() || !value.CanSet() || !value.CanAddr() || !value.CanInterface() {
                        return
                }

                vk := value.Kind()
                stepIn = stepInKinds.Contains(vk) ||
                        (vk == reflect.Ptr && value.Elem().IsValid() && value.Elem().Kind() == reflect.Struct)

                defaultString := field.Tag.Get(opt.tag)
                if IsStrBlank(defaultString) || (!opt.overwrite && !IsBlank(value)) {
                        return
                }

                defaultValue := reflect.New(value.Type()).Interface()
                if err = Unmarshal(defaultString, defaultValue, opt.unmarshalType); err != nil {
                        end = true
                        return
                }
                value.Set(reflect.ValueOf(defaultValue).Elem())
                return
        }

func poolSealer[T].Get

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/pool.go:

func (p *poolSealer[T]) Get(initialized any) (T, func()) {
        obj, ok := p.inner.Get().(T)
        if !ok {
                obj = p.newFn()
        }

        switch resettable := any(obj).(type) {
        case poolResettableA[T]:
                obj = resettable.Reset(initialized)
        case poolResettableB:
                resettable.Reset()
        case poolResettableC:
                MustSuccess(resettable.Reset())
        case poolResettableD:
                resettable.Reset(initialized)
        case poolResettableE:
                MustSuccess(resettable.Reset(initialized))
        case poolResettableF[T]:
                obj = resettable.Reset()
        }

        once := new(sync.Once)
        return obj, func() {
                once.Do(func() {
                        if p.option.evict == nil || !p.option.evict(obj) {
                                p.Put(obj)
                        }
                })
        }
}

func Catch

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/candy.go:

func Catch(fn any) (isPanic bool, err error) {
        defer func() {
                r := recover()
                if r == nil {
                        return
                }

                isPanic = true
                switch v := r.(type) {
                case error:
                        err = errors.Wrapf(v, "panic when call Catch function =>\n%s", debug.Stack())
                default:
                        err = errors.Errorf("panic when call Catch function: %s =>\n%s", r, debug.Stack())
                }
        }()

        // check supported function
        var v any
        switch f := fn.(type) {
        case func():
                f()
        case func() error:
                err = f()
        case func() (any, error):
                v, err = f()
        default:
                panic(errors.Errorf("unsupported function signature %T", fn))
        }

        if err != nil {
                return
        }
        if ve, ok := v.(error); ok {
                err = ve
        }
        return
}

func ClientIP

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/ip.go:

func ClientIP() (ip string) {
        addrs, err := net.InterfaceAddrs()
        if err != nil {
                panic(err)
        }

        for _, address := range addrs {
                if addr, ok := address.(*net.IPNet); ok && !addr.IP.IsLoopback() {
                        if addr.IP.To4() != nil {
                                return addr.IP.String()
                        }

                }
        }

        return
}

func CheckIfAny

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/candy.go:

func CheckIfAny(fnList ...func() error) error {
        for _, fn := range fnList {
                if err := fn(); err != nil {
                        return err
                }
        }
        return nil
}

func NewEnumString

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/enum.go:

func NewEnumString[T comparable, TS ~[]T](mapping map[T]string, opts ...OptionExtender) Enumerable[T, TS] {
        opt := ApplyOptions[enumStringOption](opts...)
        if len(mapping) == 0 {
                panic(errors.New("enum mapping is empty"))
        }
        return (&enumString[T, TS]{
                mapping:    mapping,
                ignoreCase: opt.ignoreCaseSensitivity,
        }).init()
}

func Max

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compare.go:

func Max[T constraint.Sortable](arr ...T) T {
        if len(arr) == 0 {
                panic(ErrEmptyArray)
        }

        max := arr[0]
        for i := 1; i < len(arr); i++ {
                if arr[i] > max {
                        max = arr[i]
                }
        }

        return max
}

func TravelCtx

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/context.go:

func TravelCtx(child context.Context, fn func(ctx context.Context) bool) {
        v := reflect.ValueOf(child)
        for p := v; p.IsValid() && p.CanInterface(); p = p.FieldByName("Context") {
                parent, ok := p.Interface().(context.Context)
                if !ok || parent == nil || fn(parent) {
                        break
                }
                if p = reflect.Indirect(p); p.Kind() != reflect.Struct {
                        break
                }
        }
}

func SliceConvert

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/conv.go:

func SliceConvert(src any, dstType reflect.Type) any {
        srcVal := reflect.ValueOf(src)
        srcType := reflect.TypeOf(src)
        dstVal := reflect.Indirect(reflect.New(dstType))
        if srcType.Kind() != reflect.Slice || dstType.Kind() != reflect.Slice {
                panic(errors.Errorf("src or dst type is invalid [src[%s] dst[%s]]", srcType.Kind(), dstType.Kind()))
        }

        isInterfaceSlice := false
        srcElemType := srcType.Elem()
        if srcType == constant.AnySliceType {
                if srcVal.Len() == 0 {
                        return dstVal.Interface()
                }
                srcElemType = reflect.TypeOf(srcVal.Index(0).Interface())
                isInterfaceSlice = true
        }

        dstElemType := dstType.Elem()
        if !srcElemType.ConvertibleTo(dstElemType) {
                panic(errors.Errorf("src elem is not convertible to dst elem [src[%s] dst[%s]]",
                        srcElemType.Kind(), dstElemType.Kind()))
        }

        length := srcVal.Len()
        for i := 0; i < length; i++ {
                srcElem := srcVal.Index(i)
                if isInterfaceSlice {
                        srcElem = reflect.ValueOf(srcVal.Index(i).Interface())
                }
                dstVal = reflect.Append(dstVal, srcElem.Convert(dstElemType))
        }

        return dstVal.Interface()
}

func IsChannelClosed

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/channel.go:

func IsChannelClosed[T any](ch <-chan T) (data T, ok bool) {
        select {
        case d, closed := <-ch:
                if closed {
                        ok = true
                        return
                }
                return d, false
        default:
                return
        }
}

func CloseAnyway

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/candy.go:

func CloseAnyway[T any](closer T) {
        if any(closer) == nil {
                return
        }

        switch c := any(closer).(type) {
        case io.Closer:
                _ = c.Close()
        case closerA:
                c.Close()
        case closerB[T]:
                c.Close()
        }
}

func Must

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/candy.go:

func Must[T any](out T, err error) T {
        if err != nil {
                panic(err)
        }
        return out
}

func .caseSensitivityConv

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/enum.go:

func (e *enumString[T, TS]) caseSensitivityConv(s string) string {
        if e.ignoreCase {
                return strings.ToLower(s)
        }
        return s
}

func GetTimeStamp

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/time.go:

func GetTimeStamp(t time.Time) int64 {
        if year := t.Year(); year >= maxYear || year < minYear {
                return t.Unix() * 1e3
        }
        return t.UnixNano() / 1e6
}

func FlushAnyway

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/candy.go:

func FlushAnyway[T any](flusher T) {
        if any(flusher) == nil {
                return
        }

        switch f := any(flusher).(type) {
        case flusherA:
                f.Flush()
        case flusherB:
                _ = f.Flush()
        }
}

func Unmarshal

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/marshal.go:

func Unmarshal(s, d any, tag unmarshalType) (err error) {
        switch s.(type) {
        case string, []byte:
                bs, cb := BytesBufferPool.Get(nil)
                defer cb()
                if ss, ok := s.(string); ok {
                        bs.WriteString(ss)
                } else {
                        bs.Write(s.([]byte))
                }

                switch tag {
                case UnmarshalTypeJson:
                        return json.NewDecoder(bs).Decode(d)
                case UnmarshalTypeYaml:
                        err = yaml.NewDecoder(bs).Decode(d)
                        return
                case UnmarshalTypeToml:
                        _, err = toml.NewDecoder(bs).Decode(d)
                        return
                default:
                        err = gob.NewDecoder(bs).Decode(d)
                        return
                }
        default:
                cfg := &mapstructure.DecoderConfig{Result: d}
                if tag != "" {
                        cfg.TagName = string(tag)
                }

                var dec *mapstructure.Decoder
                if dec, err = mapstructure.NewDecoder(cfg); err != nil {
                        return
                }
                err = dec.Decode(s)
                return
        }
}

func MustSuccess

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/candy.go:

func MustSuccess(err error) {
        if err != nil {
                panic(err)
        }
}

func HostIPInDocker

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/ip.go:

func HostIPInDocker() (ip string) {
        addrs, err := net.LookupIP("host.docker.internal")
        if err != nil {
                return
        }

        for _, addr := range addrs {
                if addr.To4() != nil {
                        return addr.String()
                }
        }
        return
}

func SortableToGeneric

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/conv.go:

func SortableToGeneric[T, K constraint.Sortable](s T) (d K) {
        switch any(d).(type) {
        case int:
                return any(cast.ToInt(s)).(K)
        case int8:
                return any(cast.ToInt8(s)).(K)
        case int16:
                return any(cast.ToInt16(s)).(K)
        case int32:
                return any(cast.ToInt32(s)).(K)
        case int64:
                return any(cast.ToInt64(s)).(K)
        case *int:
                return any(AnyPtr(cast.ToInt(s))).(K)
        case *int8:
                return any(AnyPtr(cast.ToInt8(s))).(K)
        case *int16:
                return any(AnyPtr(cast.ToInt16(s))).(K)
        case *int32:
                return any(AnyPtr(cast.ToInt32(s))).(K)
        case *int64:
                return any(AnyPtr(cast.ToInt64(s))).(K)
        case uint:
                return any(cast.ToUint(s)).(K)
        case uint8:
                return any(cast.ToUint8(s)).(K)
        case uint16:
                return any(cast.ToUint16(s)).(K)
        case uint32:
                return any(cast.ToUint32(s)).(K)
        case uint64:
                return any(cast.ToUint64(s)).(K)
        case *uint:
                return any(AnyPtr(cast.ToUint(s))).(K)
        case *uint8:
                return any(AnyPtr(cast.ToUint8(s))).(K)
        case *uint16:
                return any(AnyPtr(cast.ToUint16(s))).(K)
        case *uint32:
                return any(AnyPtr(cast.ToUint32(s))).(K)
        case *uint64:
                return any(AnyPtr(cast.ToUint64(s))).(K)
        case float32:
                return any(cast.ToFloat32(s)).(K)
        case float64:
                return any(cast.ToFloat64(s)).(K)
        case *float32:
                return any(AnyPtr(cast.ToFloat32(s))).(K)
        case *float64:
                return any(AnyPtr(cast.ToFloat64(s))).(K)
        case string:
                return any(cast.ToString(s)).(K)
        case *string:
                return any(AnyPtr(cast.ToString(s))).(K)
        default:
                panic(errors.Errorf("cannot mapping %T", d))
        }
}

func LoopWithInterval

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/time.go:

func LoopWithInterval(ctx context.Context, interval time.Duration,
        fn func() bool, opts ...OptionExtender) (err error) {
        var (
                maxTimes     uint
                nextInterval func() time.Duration
        )

        opt := ApplyOptions[loopWithIntervalOption](opts...)
        enableJitter := opt.base > 0
        enableMaxTimes := opt.maxTimes > 0
        if enableJitter {
                nextInterval = NextJitterIntervalFunc(opt.base, opt.max, opt.ratio, opt.exp, opt.symmetric)
                interval = nextInterval()
        }
        if enableMaxTimes {
                maxTimes = opt.maxTimes
        }

        timer := time.NewTimer(interval)
        defer timer.Stop()
        for {
                if fn() {
                        return
                }

                if enableMaxTimes {
                        if maxTimes--; maxTimes == 0 {
                                return multierr.Append(err, errors.New("exceed the maximum times"))
                        }
                }

                // time.Sleep
                timer.Reset(interval)
                select {
                case <-ctx.Done():
                        return ctx.Err()
                case <-timer.C:
                        if enableJitter {
                                interval = nextInterval()
                        }
                }
        }
}

func Set[T].Equals

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/sets.go:

func (s *Set[T]) Equals(o *Set[T]) bool {
        s.m.RLock()
        defer s.m.RUnlock()

        if s == nil && o == nil {
                return true
        }
        if s == nil || o == nil || s.Size() != o.Size() {
                return false
        }

        for item := range s.storage {
                if _, ok := o.storage[item]; !ok {
                        return false
                }
        }
        for item := range o.storage {
                if _, ok := s.storage[item]; !ok {
                        return false
                }
        }

        return true
}

func Set[T].IntersectsWith

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/sets.go:

func (s *Set[T]) IntersectsWith(set *Set[T]) bool {
        s.m.RLock()
        defer s.m.RUnlock()

        src := set.storage
        dst := s.storage
        if len(src) > len(dst) {
                src, dst = dst, src
        }
        for val := range src {
                if dst == nil {
                        return false
                }
                if _, ok := dst[val]; ok {
                        return true
                }
        }
        return false
}

func @132:28

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/reflect.go:

func(field reflect.StructField, value reflect.Value) (end, stepIn bool) {
                if !value.IsValid() {
                        return false, false
                }
                if value.Type().Kind() == reflect.Struct {
                        return false, true
                }
                tagV := field.Tag.Get(tag)
                if pattern.Match([]byte(tagV)) {
                        tagValue = tagV
                        end = true
                        return
                }
                return
        }

func @94:28

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/reflect.go:

func(field reflect.StructField, value reflect.Value) (end, stepIn bool) {
                if !value.IsValid() {
                        return false, false
                }
                if value.Type().Kind() == reflect.Struct {
                        return false, true
                }
                tagV := field.Tag.Get(tag)
                if tagV == key {
                        r = value
                        end = true
                        return
                }
                return
        }

func @114:28

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/reflect.go:

func(field reflect.StructField, value reflect.Value) (end, stepIn bool) {
                if !value.IsValid() {
                        return false, false
                }
                if value.Type().Kind() == reflect.Struct {
                        return false, true
                }
                if keySet.Contains(field.Tag.Get(tag)) {
                        r = value
                        end = true
                        return
                }
                return
        }

func @100:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/func.go:

func(a ...any) (t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) {
                ret := runVariadicFunc(fn, a...)
                t1 = ParseVariadicFuncResult[T1](ret, 0)
                t2 = ParseVariadicFuncResult[T2](ret, 1)
                t3 = ParseVariadicFuncResult[T3](ret, 2)
                t4 = ParseVariadicFuncResult[T4](ret, 3)
                t5 = ParseVariadicFuncResult[T5](ret, 4)
                t6 = ParseVariadicFuncResult[T6](ret, 5)
                t7 = ParseVariadicFuncResult[T7](ret, 6)
                return
        }

func Set[T].IsSubsetOf

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/sets.go:

func (s *Set[T]) IsSubsetOf(set *Set[T]) bool {
        s.m.RLock()
        defer s.m.RUnlock()

        for val := range s.storage {
                // The empty set is a subset of all sets, but in common business use,
                // there is rarely such a mathematical interpretation of the empty set being considered as
                // a subset relationship, so false is chosen here.
                if set == nil {
                        return false
                }
                if _, ok := set.storage[val]; !ok {
                        return false
                }
        }
        return true
}

func @87:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/func.go:

func(a ...any) (t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) {
                ret := runVariadicFunc(fn, a...)
                t1 = ParseVariadicFuncResult[T1](ret, 0)
                t2 = ParseVariadicFuncResult[T2](ret, 1)
                t3 = ParseVariadicFuncResult[T3](ret, 2)
                t4 = ParseVariadicFuncResult[T4](ret, 3)
                t5 = ParseVariadicFuncResult[T5](ret, 4)
                t6 = ParseVariadicFuncResult[T6](ret, 5)
                return
        }

func CryptoRandomLetterAndNumber

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/random.go:

func CryptoRandomLetterAndNumber(n int) (string, error) {
        b, err := CryptoRandomBytes(n)
        if err != nil {
                return "", err
        }

        random := make([]byte, 0, n)
        for i := 0; i < n; i++ {
                random = append(random, randomChars[b[i]%uint8(randomCharsLength)])
        }
        return string(random), nil
}

func CryptoRandomNumbers

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/random.go:

func CryptoRandomNumbers(n int) (string, error) {
        b, err := CryptoRandomBytes(n)
        if err != nil {
                return "", err
        }

        random := make([]byte, 0, n)
        for i := 0; i < n; i++ {
                random = append(random, randomChars[b[i]%uint8(10)])
        }
        return string(random), nil
}

func @75:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/func.go:

func(a ...any) (t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) {
                ret := runVariadicFunc(fn, a...)
                t1 = ParseVariadicFuncResult[T1](ret, 0)
                t2 = ParseVariadicFuncResult[T2](ret, 1)
                t3 = ParseVariadicFuncResult[T3](ret, 2)
                t4 = ParseVariadicFuncResult[T4](ret, 3)
                t5 = ParseVariadicFuncResult[T5](ret, 4)
                return
        }

func JsonStringify[T].UnmarshalJSON

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/marshal.go:

func (j *JsonStringify[T]) UnmarshalJSON(input []byte) (err error) {
        var buf string
        if err = json.Unmarshal(input, &buf); err != nil {
                return
        }
        if err = json.Unmarshal(UnsafeStringToBytes(buf), &j.Value); err != nil {
                return
        }
        return
}

func JsonStringify[T].MarshalJSON

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/marshal.go:

func (j *JsonStringify[T]) MarshalJSON() (output []byte, err error) {
        var buf []byte
        if buf, err = json.Marshal(j.Value); err != nil {
                return
        }
        if output, err = json.Marshal(buf); err != nil {
                return
        }
        return
}

func Set[T].Filter

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/sets.go:

func (s *Set[T]) Filter(fn func(T) bool) *Set[T] {
        s.m.Lock()
        defer s.m.Unlock()

        for key := range s.storage {
                if !fn(key) {
                        delete(s.storage, key)
                }
        }
        return s
}

func @64:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/func.go:

func(a ...any) (t1 T1, t2 T2, t3 T3, t4 T4) {
                ret := runVariadicFunc(fn, a...)
                t1 = ParseVariadicFuncResult[T1](ret, 0)
                t2 = ParseVariadicFuncResult[T2](ret, 1)
                t3 = ParseVariadicFuncResult[T3](ret, 2)
                t4 = ParseVariadicFuncResult[T4](ret, 3)
                return
        }

func Set[T].Reject

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/sets.go:

func (s *Set[T]) Reject(fn func(T) bool) *Set[T] {
        s.m.Lock()
        defer s.m.Unlock()

        for key := range s.storage {
                if fn(key) {
                        delete(s.storage, key)
                }
        }
        return s
}

func InvalidUnmarshalError.Error

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/marshal.go:

func (e *InvalidUnmarshalError) Error() string {
        if e.Type == nil {
                return "common/utils: Unmarshal(nil)"
        }

        if e.Type.Kind() != reflect.Pointer {
                return "common/utils: Unmarshal(non-pointer " + e.Type.String() + ")"
        }
        return "common/utils: Unmarshal(nil " + e.Type.String() + ")"
}

func @54:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/time.go:

func(o *loopWithIntervalOption) {
                o.base = base
                o.max = max
                o.ratio = ratio
                o.exp = exp
                o.symmetric = symmetric
        }

func Heap[E].Copy

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/heap.go:

func (h *Heap[E]) Copy() *Heap[E] {
        ret := &_heap[E]{cmp: h.data.cmp}
        ret.d = make([]E, len(h.data.d))
        copy(ret.d, h.data.d)
        heap.Init(ret)
        return &Heap[E]{data: ret}
}

func RandomNumbers

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/random.go:

func RandomNumbers(n int) string {
        rand.Seed(time.Now().UnixNano())
        ret := ""
        for i := 0; i < n; i++ {
                ret += strconv.Itoa(rand.Intn(10))
        }
        return ret
}

func @54:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/func.go:

func(a ...any) (t1 T1, t2 T2, t3 T3) {
                ret := runVariadicFunc(fn, a...)
                t1 = ParseVariadicFuncResult[T1](ret, 0)
                t2 = ParseVariadicFuncResult[T2](ret, 1)
                t3 = ParseVariadicFuncResult[T3](ret, 2)
                return
        }

func @23:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/func.go:

func(a ...any) (b []any) {
                ret := runVariadicFunc(fn, a...)
                b = make([]any, 0, len(b))
                for i := 0; i < len(ret); i++ {
                        b = append(b, ret[i].Interface())
                }
                return
        }

func MapSliceToMap

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/map.go:

func MapSliceToMap[T comparable, K any](s []map[T]K) (d map[T]K) {
        d = make(map[T]K, len(s))
        for _, kv := range s {
                for k, v := range kv {
                        d[k] = v
                }
        }
        return
}

func DecimalPlaces

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/number.go:

func DecimalPlaces(num float64) int {
        str := strconv.FormatFloat(num, 'f', -1, 64)
        if i := strings.LastIndex(str, "."); i >= 0 {
                return len(str[i+1:])
        }
        return 0
}

func CryptoRandomBytes

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/random.go:

func CryptoRandomBytes(size int) ([]byte, error) {
        b := make([]byte, size)
        if _, err := cryptoRand.Read(b); err != nil {
                return nil, err
        }
        return b, nil
}

func UUID20

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/random.go:

func UUID20() string {
        id := uuid.New()
        t := make([]byte, ascii85.MaxEncodedLen(len(id)))
        n := ascii85.Encode(t, id[:])
        return string(t[:n])
}

func SliceRemove

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/slice.go:

func SliceRemove[T any, TS ~[]T](s TS, filter func(t T) bool) (d TS) {
        for i, item := range s {
                if filter(item) {
                        s = append(s[i:], s[i+1:]...)
                }
        }
        return s
}

func GetFieldByTagWithKeys

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/reflect.go:

func GetFieldByTagWithKeys(data any, tag string, keys []string) (r reflect.Value, e error) {
        keySet := NewSet[string](keys...)
        TraverseValue(data, true, func(field reflect.StructField, value reflect.Value) (end, stepIn bool) {
                if !value.IsValid() {
                        return false, false
                }
                if value.Type().Kind() == reflect.Struct {
                        return false, true
                }
                if keySet.Contains(field.Tag.Get(tag)) {
                        r = value
                        end = true
                        return
                }
                return
        })
        return
}

func NewHeap

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/heap.go:

func NewHeap[E any](t []E, cmp func(e1, e2 E) int) *Heap[E] {
        ret := &_heap[E]{d: t, cmp: cmp}
        heap.Init(ret)
        return &Heap[E]{data: ret}
}

func Set[T].Size

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/sets.go:

func (s *Set[T]) Size() int {
        s.m.RLock()
        defer s.m.RUnlock()
        return len(s.storage)
}

func Set[T].Clone

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/sets.go:

func (s *Set[T]) Clone() (r *Set[T]) {
        s.m.RLock()
        defer s.m.RUnlock()
        return NewSet(s.Items()...)
}

func Heap[E].Element

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/heap.go:

func (h *Heap[E]) Element(index int) (e E, err error) {
        if index < 0 || index >= h.data.Len() {
                return e, ErrOutOfRange
        }
        return h.data.d[index], nil
}

func IsInRange

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compare.go:

func IsInRange[T constraint.Sortable](num, min, max T) bool {
        if num < min || num > max {
                return false
        }
        return true
}

func MustOk

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/candy.go:

func MustOk[T any](out T, ok bool) T {
        if !ok {
                panic(errors.Errorf("get %T with ok is false", out))
        }
        return out
}

func UUID22

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/random.go:

49	`func UUID22() string {`
50	`id := uuid.New()`
51	`return base64.RawURLEncoding.EncodeToString(id[:])`
52	`}`

func GetFieldTagValue

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/reflect.go:

func GetFieldTagValue(data any, tag string, pattern *regexp.Regexp) (tagValue string, e error) {
        TraverseValue(data, true, func(field reflect.StructField, value reflect.Value) (end, stepIn bool) {
                if !value.IsValid() {
                        return false, false
                }
                if value.Type().Kind() == reflect.Struct {
                        return false, true
                }
                tagV := field.Tag.Get(tag)
                if pattern.Match([]byte(tagV)) {
                        tagValue = tagV
                        end = true
                        return
                }
                return
        })
        return
}

func IntNarrow

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/number.go:

func IntNarrow(num int) (result any) {
        IfAny(
                func() bool { result = int8(num); return IsInRange(num, math.MinInt8, math.MaxInt8) },
                func() bool { result = int16(num); return IsInRange(num, math.MinInt16, math.MaxInt16) },
                func() bool { result = int32(num); return IsInRange(num, math.MinInt32, math.MaxInt32) },
                func() bool { result = int64(num); return IsInRange(num, math.MinInt64, math.MaxInt64) },
        )
        return
}

func GetFieldByTag

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/reflect.go:

func GetFieldByTag(data any, tag, key string) (r reflect.Value, e error) {
        TraverseValue(data, true, func(field reflect.StructField, value reflect.Value) (end, stepIn bool) {
                if !value.IsValid() {
                        return false, false
                }
                if value.Type().Kind() == reflect.Struct {
                        return false, true
                }
                tagV := field.Tag.Get(tag)
                if tagV == key {
                        r = value
                        end = true
                        return
                }
                return
        })
        return
}

func @19:3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/number.go:

19	`func() bool { result = int8(num); return IsInRange(num, math.MinInt8, math.MaxInt8) }`

func @20:3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/number.go:

20	`func() bool { result = int16(num); return IsInRange(num, math.MinInt16, math.MaxInt16) }`

func @181:3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/random.go:

181	`func() bool {`
182	`_, err = Catch(func() { inspect.SetField(source, "s", rand.NewSource(seed)) })`
183	`return err == nil`
184	`}`

func @21:3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/number.go:

21	`func() bool { result = int32(num); return IsInRange(num, math.MinInt32, math.MaxInt32) }`

func @22:3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/number.go:

22	`func() bool { result = int64(num); return IsInRange(num, math.MinInt64, math.MaxInt64) }`

func @29:3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/number.go:

29	`func() bool { result = uint8(num); return IsInRange(num, 0, math.MaxUint8) }`

func IsValidTimestamp

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/time.go:

38	`func IsValidTimestamp(timeMS int64) bool {`
39	`year := GetTime(timeMS).Year()`
40	`return year >= minYear && year < maxYear`
41	`}`

func @30:3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/number.go:

30	`func() bool { result = uint16(num); return IsInRange(num, 0, math.MaxUint16) }`

func @31:3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/number.go:

31	`func() bool { result = uint32(num); return IsInRange(num, 0, math.MaxUint32) }`

func _heap[E].Pop

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/heap.go:

21	`func (h *_heap[E]) Pop() (x any) { x, h.d = h.d[len(h.d)-1], h.d[0:len(h.d)-1]; return x }`

func Sort

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/sort.go:

5	`func Sort[E any](data []E, cmp func(e1, e2 E) int) {`
6	`sortObj := sortable[E]{data: data, cmp: cmp}`
7	`sort.Sort(sortObj)`
8	`}`

func SortStable

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/sort.go:

10	`func SortStable[E any](data []E, cmp func(e1, e2 E) int) {`
11	`sortObj := sortable[E]{data: data, cmp: cmp}`
12	`sort.Stable(sortObj)`
13	`}`

func _heap[E].Push

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/heap.go:

20	`func (h *_heap[E]) Push(x any) { v := append(h.d, x.(E)); h.d = v }`

func _heap[E].Less

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/heap.go:

18	`func (h *_heap[E]) Less(i, j int) bool { v := h.cmp(h.d[i], h.d[j]); return v < 0 }`

func @32:3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/number.go:

32	`func() bool { result = uint64(num); return IsInRange(num, 0, math.MaxUint64) }`

func UintNarrow

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/number.go:

func UintNarrow(num uint) (result any) {
        IfAny(
                func() bool { result = uint8(num); return IsInRange(num, 0, math.MaxUint8) },
                func() bool { result = uint16(num); return IsInRange(num, 0, math.MaxUint16) },
                func() bool { result = uint32(num); return IsInRange(num, 0, math.MaxUint32) },
                func() bool { result = uint64(num); return IsInRange(num, 0, math.MaxUint64) },
        )
        return
}

func UnsafeBytesToString

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/conv.go:

160	`func UnsafeBytesToString(b []byte) string {`
161	`return (string)(unsafe.Pointer(&b))`
162	`}`

func IsStrPtrBlank

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/string.go:

15	`func IsStrPtrBlank(s *string) bool {`
16	`return s == nil \|\| IsStrBlank(*s)`
17	`}`

func UnsafeStringToBytes

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/conv.go:

func UnsafeStringToBytes(s string) []byte {
        return *(*[]byte)(unsafe.Pointer(
                &struct {
                        string
                        Cap int
                }{s, len(s)},
        ))
}

func WrapFunc7

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/func.go:

func WrapFunc7[T1, T2, T3, T4, T5, T6, T7 any](fn any) func(...any) (T1, T2, T3, T4, T5, T6, T7) {
        return func(a ...any) (t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) {
                ret := runVariadicFunc(fn, a...)
                t1 = ParseVariadicFuncResult[T1](ret, 0)
                t2 = ParseVariadicFuncResult[T2](ret, 1)
                t3 = ParseVariadicFuncResult[T3](ret, 2)
                t4 = ParseVariadicFuncResult[T4](ret, 3)
                t5 = ParseVariadicFuncResult[T5](ret, 4)
                t6 = ParseVariadicFuncResult[T6](ret, 5)
                t7 = ParseVariadicFuncResult[T7](ret, 6)
                return
        }
}

func UUID_

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/random.go:

28	`func UUID_() string {`
29	`return strings.Replace(uuid.New().String(), constant.Hyphen, "", -1)`
30	`}`

func sortable[E].Less

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/sort.go:

22	`func (s sortable[E]) Less(i, j int) bool { return s.cmp(s.data[i], s.data[j]) < 0 }`

func sortable[E].Swap

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/sort.go:

21	`func (s sortable[E]) Swap(i, j int) { s.data[i], s.data[j] = s.data[j], s.data[i] }`

func _heap[E].Swap

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/heap.go:

19	`func (h *_heap[E]) Swap(i, j int) { h.d[i], h.d[j] = h.d[j], h.d[i] }`

func sortable[E].Len

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/sort.go:

20	`func (s sortable[E]) Len() int { return len(s.data) }`

func @26:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/enum.go:

26	`func(e *enumStringOption) {`
27	`e.ignoreCaseSensitivity = true`
28	`}`

func Heap[E].Push

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/heap.go:

30	`func (h *Heap[E]) Push(v E) { heap.Push(h.data, v) }`

func ParseTagOverwrite

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/tag.go:

func ParseTagOverwrite(overwrite bool) OptionFunc[parseTagOption] {
        return func(o *parseTagOption) {
                o.overwrite = overwrite
        }
}

func @20:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/tag.go:

20	`func(o *parseTagOption) {`
21	`o.overwrite = overwrite`
22	`}`

func Heap[E].Pop

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/heap.go:

35	`func (h *Heap[E]) Pop() E { return heap.Pop(h.data).(E) }`

func Heap[E].Remove

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/heap.go:

46	`func (h *Heap[E]) Remove(index int) E { return heap.Remove(h.data, index).(E) }`

func Heap[E].Len

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/heap.go:

47	`func (h *Heap[E]) Len() int { return len(h.data.d) }`

func WrapFuncAny

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/func.go:

func WrapFuncAny(fn any) func(...any) []any {
        return func(a ...any) (b []any) {
                ret := runVariadicFunc(fn, a...)
                b = make([]any, 0, len(b))
                for i := 0; i < len(ret); i++ {
                        b = append(b, ret[i].Interface())
                }
                return
        }
}

func GetTime

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/time.go:

25	`func GetTime(timestampMs int64) time.Time {`
26	`return time.UnixMilli(timestampMs)`
27	`}`

func IgnoreEnumStringCase

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/enum.go:

func IgnoreEnumStringCase() enumStringOptFn {
        return func(e *enumStringOption) {
                e.ignoreCaseSensitivity = true
        }
}

func WrapFunc6

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/func.go:

func WrapFunc6[T1, T2, T3, T4, T5, T6 any](fn any) func(...any) (T1, T2, T3, T4, T5, T6) {
        return func(a ...any) (t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) {
                ret := runVariadicFunc(fn, a...)
                t1 = ParseVariadicFuncResult[T1](ret, 0)
                t2 = ParseVariadicFuncResult[T2](ret, 1)
                t3 = ParseVariadicFuncResult[T3](ret, 2)
                t4 = ParseVariadicFuncResult[T4](ret, 3)
                t5 = ParseVariadicFuncResult[T5](ret, 4)
                t6 = ParseVariadicFuncResult[T6](ret, 5)
                return
        }
}

func LoopJitterInterval

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/time.go:

func LoopJitterInterval(base, max time.Duration, ratio, exp float64,
        symmetric bool) OptionFunc[loopWithIntervalOption] {
        return func(o *loopWithIntervalOption) {
                o.base = base
                o.max = max
                o.ratio = ratio
                o.exp = exp
                o.symmetric = symmetric
        }
}

func WrapFunc5

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/func.go:

func WrapFunc5[T1, T2, T3, T4, T5 any](fn any) func(...any) (T1, T2, T3, T4, T5) {
        return func(a ...any) (t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) {
                ret := runVariadicFunc(fn, a...)
                t1 = ParseVariadicFuncResult[T1](ret, 0)
                t2 = ParseVariadicFuncResult[T2](ret, 1)
                t3 = ParseVariadicFuncResult[T3](ret, 2)
                t4 = ParseVariadicFuncResult[T4](ret, 3)
                t5 = ParseVariadicFuncResult[T5](ret, 4)
                return
        }
}

func LoopMaxTimes

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/time.go:

func LoopMaxTimes(maxTimes uint) OptionFunc[loopWithIntervalOption] {
        return func(o *loopWithIntervalOption) {
                o.maxTimes = maxTimes
        }
}

func @65:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/time.go:

65	`func(o *loopWithIntervalOption) {`
66	`o.maxTimes = maxTimes`
67	`}`

func NewSafeRand

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/random.go:

165	`func NewSafeRand(seed int64) *rand.Rand {`
166	`return rand.New(newBuiltinLockedSource(seed))`
167	`}`

func WrapFunc4

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/func.go:

func WrapFunc4[T1, T2, T3, T4 any](fn any) func(...any) (T1, T2, T3, T4) {
        return func(a ...any) (t1 T1, t2 T2, t3 T3, t4 T4) {
                ret := runVariadicFunc(fn, a...)
                t1 = ParseVariadicFuncResult[T1](ret, 0)
                t2 = ParseVariadicFuncResult[T2](ret, 1)
                t3 = ParseVariadicFuncResult[T3](ret, 2)
                t4 = ParseVariadicFuncResult[T4](ret, 3)
                return
        }
}

func @182:19

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/random.go:

182	`func() { inspect.SetField(source, "s", rand.NewSource(seed)) }`

func WrapFunc3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/func.go:

func WrapFunc3[T1, T2, T3 any](fn any) func(...any) (T1, T2, T3) {
        return func(a ...any) (t1 T1, t2 T2, t3 T3) {
                ret := runVariadicFunc(fn, a...)
                t1 = ParseVariadicFuncResult[T1](ret, 0)
                t2 = ParseVariadicFuncResult[T2](ret, 1)
                t3 = ParseVariadicFuncResult[T3](ret, 2)
                return
        }
}

func Error.Error

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/error.go:

5	`func (e Error) Error() string {`
6	`return string(e)`
7	`}`

func MustJsonMarshalString

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/marshal.go:

42	`func MustJsonMarshalString(s any) string { return string(MustJsonMarshal(s)) }`

func _heap[E].Len

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/heap.go:

17	`func (h *_heap[E]) Len() int { return len(h.d) }`

Package Overview: github.com/wfusion/gofusion/common/utils/cipher 85.6%

Please select a function to see what's left for testing.

`newBlockModeWrapper(...)`	`github.com/wfusion/gofusion/common/utils/cipher/block_mode_wrapper.go`	`100.0%`	`7/7`
`@36:8(...)`	`github.com/wfusion/gofusion/common/utils/cipher/encrypt.go`	`100.0%`	`6/6`
`EncryptStreamFunc(...)`	`github.com/wfusion/gofusion/common/utils/cipher/encrypt.go`	`100.0%`	`6/6`
`@40:8(...)`	`github.com/wfusion/gofusion/common/utils/cipher/decrypt.go`	`100.0%`	`6/6`
`enc.Flush(...)`	`github.com/wfusion/gofusion/common/utils/cipher/encrypt.go`	`100.0%`	`4/4`
`dec.Close(...)`	`github.com/wfusion/gofusion/common/utils/cipher/decrypt.go`	`100.0%`	`4/4`
`@159:8(...)`	`github.com/wfusion/gofusion/common/utils/cipher/encrypt.go`	`100.0%`	`3/3`
`@28:9(...)`	`github.com/wfusion/gofusion/common/utils/cipher/block_mode_wrapper.go`	`100.0%`	`3/3`
`@233:8(...)`	`github.com/wfusion/gofusion/common/utils/cipher/encrypt.go`	`100.0%`	`3/3`
`@19:9(...)`	`github.com/wfusion/gofusion/common/utils/cipher/encrypt.go`	`100.0%`	`3/3`
`@162:8(...)`	`github.com/wfusion/gofusion/common/utils/cipher/decrypt.go`	`100.0%`	`3/3`
`wrapErr(...)`	`github.com/wfusion/gofusion/common/utils/cipher/types.go`	`100.0%`	`2/2`
`newAbstractAEADWrapper(...)`	`github.com/wfusion/gofusion/common/utils/cipher/aead_wrapper.go`	`100.0%`	`2/2`
`@54:8(...)`	`github.com/wfusion/gofusion/common/utils/cipher/encrypt.go`	`100.0%`	`2/2`
`enc.Close(...)`	`github.com/wfusion/gofusion/common/utils/cipher/encrypt.go`	`100.0%`	`2/2`
`@36:9(...)`	`github.com/wfusion/gofusion/common/utils/cipher/block_mode_wrapper.go`	`100.0%`	`2/2`
`@43:9(...)`	`github.com/wfusion/gofusion/common/utils/cipher/block_mode_wrapper.go`	`100.0%`	`2/2`
`Mode.NeedIV(...)`	`github.com/wfusion/gofusion/common/utils/cipher/mode_enum.go`	`100.0%`	`1/1`
`wrapStream(...)`	`github.com/wfusion/gofusion/common/utils/cipher/block_mode_wrapper.go`	`100.0%`	`1/1`
`blockModeWrapper.CipherMode(...)`	`github.com/wfusion/gofusion/common/utils/cipher/block_mode_wrapper.go`	`100.0%`	`1/1`
`blockModeWrapper.PlainBlockSize(...)`	`github.com/wfusion/gofusion/common/utils/cipher/block_mode_wrapper.go`	`100.0%`	`1/1`
`wrapBlockMode(...)`	`github.com/wfusion/gofusion/common/utils/cipher/block_mode_wrapper.go`	`100.0%`	`1/1`
`@74:12(...)`	`github.com/wfusion/gofusion/common/utils/cipher/types.go`	`100.0%`	`1/1`
`@59:12(...)`	`github.com/wfusion/gofusion/common/utils/cipher/types.go`	`100.0%`	`1/1`
`@54:12(...)`	`github.com/wfusion/gofusion/common/utils/cipher/types.go`	`100.0%`	`1/1`
`@49:12(...)`	`github.com/wfusion/gofusion/common/utils/cipher/types.go`	`100.0%`	`1/1`
`@35:23(...)`	`github.com/wfusion/gofusion/common/utils/cipher/decrypt.go`	`100.0%`	`1/1`
`blockModeWrapper.CipherBlockSize(...)`	`github.com/wfusion/gofusion/common/utils/cipher/block_mode_wrapper.go`	`100.0%`	`1/1`
`@44:12(...)`	`github.com/wfusion/gofusion/common/utils/cipher/types.go`	`100.0%`	`1/1`
`@39:12(...)`	`github.com/wfusion/gofusion/common/utils/cipher/types.go`	`100.0%`	`1/1`
`@35:18(...)`	`github.com/wfusion/gofusion/common/utils/cipher/types.go`	`100.0%`	`1/1`
`wrapBlock(...)`	`github.com/wfusion/gofusion/common/utils/cipher/block_mode_wrapper.go`	`100.0%`	`1/1`
`@165:9(...)`	`github.com/wfusion/gofusion/common/utils/cipher/decrypt.go`	`100.0%`	`1/1`
`Mode.IsValid(...)`	`github.com/wfusion/gofusion/common/utils/cipher/mode_enum.go`	`100.0%`	`1/1`
`@79:12(...)`	`github.com/wfusion/gofusion/common/utils/cipher/types.go`	`100.0%`	`1/1`
`@34:18(...)`	`github.com/wfusion/gofusion/common/utils/cipher/types.go`	`100.0%`	`1/1`
`Algorithm.String(...)`	`github.com/wfusion/gofusion/common/utils/cipher/algorithm_enum.go`	`100.0%`	`1/1`
`@89:12(...)`	`github.com/wfusion/gofusion/common/utils/cipher/types.go`	`100.0%`	`1/1`
`@31:23(...)`	`github.com/wfusion/gofusion/common/utils/cipher/encrypt.go`	`100.0%`	`1/1`
`newAEADDecryptWrapper(...)`	`github.com/wfusion/gofusion/common/utils/cipher/aead_wrapper.go`	`100.0%`	`1/1`
`@33:18(...)`	`github.com/wfusion/gofusion/common/utils/cipher/types.go`	`100.0%`	`1/1`
`@94:12(...)`	`github.com/wfusion/gofusion/common/utils/cipher/types.go`	`100.0%`	`1/1`
`@32:18(...)`	`github.com/wfusion/gofusion/common/utils/cipher/types.go`	`100.0%`	`1/1`
`Algorithm.IsValid(...)`	`github.com/wfusion/gofusion/common/utils/cipher/algorithm_enum.go`	`100.0%`	`1/1`
`newAEADEncryptWrapper(...)`	`github.com/wfusion/gofusion/common/utils/cipher/aead_wrapper.go`	`100.0%`	`1/1`
`@162:9(...)`	`github.com/wfusion/gofusion/common/utils/cipher/encrypt.go`	`100.0%`	`1/1`
`rc4Wrapper.CipherBlockSize(...)`	`github.com/wfusion/gofusion/common/utils/cipher/rc4_wrapper.go`	`100.0%`	`1/1`
`rc4Wrapper.PlainBlockSize(...)`	`github.com/wfusion/gofusion/common/utils/cipher/rc4_wrapper.go`	`100.0%`	`1/1`
`abstractAEADWrapper.CipherMode(...)`	`github.com/wfusion/gofusion/common/utils/cipher/aead_wrapper.go`	`100.0%`	`1/1`
`abstractAEADWrapper.CipherBlockSize(...)`	`github.com/wfusion/gofusion/common/utils/cipher/aead_wrapper.go`	`100.0%`	`1/1`
`abstractAEADWrapper.PlainBlockSize(...)`	`github.com/wfusion/gofusion/common/utils/cipher/aead_wrapper.go`	`100.0%`	`1/1`
`rc4Wrapper.CipherMode(...)`	`github.com/wfusion/gofusion/common/utils/cipher/rc4_wrapper.go`	`100.0%`	`1/1`
`Mode.String(...)`	`github.com/wfusion/gofusion/common/utils/cipher/mode_enum.go`	`100.0%`	`1/1`
`Mode.SupportStream(...)`	`github.com/wfusion/gofusion/common/utils/cipher/mode_enum.go`	`100.0%`	`1/1`
`Mode.ShouldPadding(...)`	`github.com/wfusion/gofusion/common/utils/cipher/mode_enum.go`	`100.0%`	`1/1`
`@84:12(...)`	`github.com/wfusion/gofusion/common/utils/cipher/types.go`	`100.0%`	`1/1`
`encrypt(...)`	`github.com/wfusion/gofusion/common/utils/cipher/encrypt.go`	`92.6%`	`25/27`
`decrypt(...)`	`github.com/wfusion/gofusion/common/utils/cipher/decrypt.go`	`92.3%`	`24/26`
`NewEncFunc(...)`	`github.com/wfusion/gofusion/common/utils/cipher/encrypt.go`	`92.3%`	`12/13`
`dec.Read(...)`	`github.com/wfusion/gofusion/common/utils/cipher/decrypt.go`	`89.7%`	`35/39`
`enc.Write(...)`	`github.com/wfusion/gofusion/common/utils/cipher/encrypt.go`	`89.5%`	`17/19`
`NewDecFunc(...)`	`github.com/wfusion/gofusion/common/utils/cipher/decrypt.go`	`84.6%`	`11/13`
`@19:9(...)`	`github.com/wfusion/gofusion/common/utils/cipher/decrypt.go`	`83.3%`	`5/6`
`DecryptStreamFunc(...)`	`github.com/wfusion/gofusion/common/utils/cipher/decrypt.go`	`83.3%`	`5/6`
`EncryptBytesFunc(...)`	`github.com/wfusion/gofusion/common/utils/cipher/encrypt.go`	`83.3%`	`5/6`
`blockModeWrapper.CryptBlocks(...)`	`github.com/wfusion/gofusion/common/utils/cipher/block_mode_wrapper.go`	`81.8%`	`9/11`
`aeadEncryptWrapper.CryptBlocks(...)`	`github.com/wfusion/gofusion/common/utils/cipher/aead_wrapper.go`	`81.8%`	`9/11`
`@126:31(...)`	`github.com/wfusion/gofusion/common/utils/cipher/types.go`	`80.0%`	`4/5`
`@136:17(...)`	`github.com/wfusion/gofusion/common/utils/cipher/types.go`	`80.0%`	`4/5`
`@118:30(...)`	`github.com/wfusion/gofusion/common/utils/cipher/types.go`	`80.0%`	`4/5`
`@144:30(...)`	`github.com/wfusion/gofusion/common/utils/cipher/types.go`	`80.0%`	`4/5`
`@110:17(...)`	`github.com/wfusion/gofusion/common/utils/cipher/types.go`	`80.0%`	`4/5`
`DecryptBytesFunc(...)`	`github.com/wfusion/gofusion/common/utils/cipher/decrypt.go`	`80.0%`	`4/5`
`rc4Wrapper.CryptBlocks(...)`	`github.com/wfusion/gofusion/common/utils/cipher/rc4_wrapper.go`	`80.0%`	`4/5`
`@152:31(...)`	`github.com/wfusion/gofusion/common/utils/cipher/types.go`	`80.0%`	`4/5`
`@99:12(...)`	`github.com/wfusion/gofusion/common/utils/cipher/types.go`	`80.0%`	`4/5`
`@64:12(...)`	`github.com/wfusion/gofusion/common/utils/cipher/types.go`	`80.0%`	`4/5`
`aeadDecryptWrapper.CryptBlocks(...)`	`github.com/wfusion/gofusion/common/utils/cipher/aead_wrapper.go`	`76.9%`	`10/13`
`PKCS7Pad(...)`	`github.com/wfusion/gofusion/common/utils/cipher/padding.go`	`75.0%`	`3/4`
`getEncrypter(...)`	`github.com/wfusion/gofusion/common/utils/cipher/encrypt.go`	`70.0%`	`14/20`
`getDecrypter(...)`	`github.com/wfusion/gofusion/common/utils/cipher/decrypt.go`	`70.0%`	`14/20`
`enc.flush(...)`	`github.com/wfusion/gofusion/common/utils/cipher/encrypt.go`	`70.0%`	`7/10`
`PKCS7Unpad(...)`	`github.com/wfusion/gofusion/common/utils/cipher/padding.go`	`70.0%`	`7/10`
`ParseMode(...)`	`github.com/wfusion/gofusion/common/utils/cipher/mode_enum.go`	`50.0%`	`3/6`
`ParseAlgorithm(...)`	`github.com/wfusion/gofusion/common/utils/cipher/algorithm_enum.go`	`50.0%`	`3/6`
`Algorithm.Value(...)`	`github.com/wfusion/gofusion/common/utils/cipher/algorithm_enum.go`	`0.0%`	`0/1`
`Mode.Value(...)`	`github.com/wfusion/gofusion/common/utils/cipher/mode_enum.go`	`0.0%`	`0/1`

func newBlockModeWrapper

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/block_mode_wrapper.go:

func newBlockModeWrapper(opts ...utils.OptionExtender) (w *blockModeWrapper) {
        opt := utils.ApplyOptions[blockModeOption](opts...)
        w = &blockModeWrapper{
                block:     opt.block,
                blockMode: opt.blockMode,
                stream:    opt.stream,
                blockSize: 0,
                mode:      opt.mode,
                isEncoder: opt.isEncoder,
        }

        switch {
        case opt.block != nil:
                w.blockSize = w.block.BlockSize()
        case opt.blockMode != nil:
                w.blockSize = w.blockMode.BlockSize()
        case opt.stream != nil:
                w.blockSize = defaultBlockSize * blockSizeTimes
        }

        return
}

func @36:8

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/encrypt.go:

func(dst io.Writer, src io.Reader) (err error) {
                buf, cb := utils.BytesPool.Get(defaultBlockSize * blockSizeTimes)
                defer cb()

                wrapper := fn(dst)
                defer utils.CloseAnyway(wrapper)

                _, err = io.CopyBuffer(wrapper, src, buf)
                return
        }

func EncryptStreamFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/encrypt.go:

func EncryptStreamFunc(algo Algorithm, mode Mode, key, iv []byte) (
        enc func(dst io.Writer, src io.Reader) (err error), err error) {
        var fn func(w io.Writer) io.WriteCloser

        _, err = utils.Catch(func() { fn = NewEncFunc(algo, mode, key, iv) })
        if err != nil {
                return nil, err
        }

        enc = func(dst io.Writer, src io.Reader) (err error) {
                buf, cb := utils.BytesPool.Get(defaultBlockSize * blockSizeTimes)
                defer cb()

                wrapper := fn(dst)
                defer utils.CloseAnyway(wrapper)

                _, err = io.CopyBuffer(wrapper, src, buf)
                return
        }

        return
}

func @40:8

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/decrypt.go:

func(dst io.Writer, src io.Reader) (err error) {
                buf, cb := utils.BytesPool.Get(defaultBlockSize * blockSizeTimes)
                defer cb()

                wrapper := fn(src)
                defer utils.CloseAnyway(wrapper)
                _, err = io.CopyBuffer(dst, wrapper, buf)
                return
        }

func enc.Flush

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/encrypt.go:

func (e *enc) Flush() (err error) {
        defer utils.FlushAnyway(e.w)
        if e.n > 0 {
                err = e.flush()
        }
        return
}

func dec.Close

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/decrypt.go:

func (d *dec) Close() (err error) {
        utils.CloseAnyway(d.r)
        if d.cb != nil {
                d.cb()
        }
        return
}

func @159:8

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/encrypt.go:

159	`func() { bcb(); scb(); sbcb() }`

func @28:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/block_mode_wrapper.go:

func(o *blockModeOption) {
                o.mode = mode
                o.block = block
                o.isEncoder = isEncoder
        }

func @233:8

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/encrypt.go:

233	`func() {`
234	`utils.CloseAnyway(e.w)`
235	`if e.cb != nil {`
236	`e.cb()`
237	`}`
238	`}`

func @19:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/encrypt.go:

func(src []byte) (dst []byte, err error) {
                if mode.ShouldPadding() {
                        src = PKCS7Pad(src, plainBlockSize)
                }
                return encrypt(bm, src)
        }

func @162:8

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/decrypt.go:

162	`func() { bcb(); ucb(); ubcb() }`

func wrapErr

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/types.go:

163	`func wrapErr[T any](a T) (b T, err error) { b = a; return }`

func newAbstractAEADWrapper

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/aead_wrapper.go:

func newAbstractAEADWrapper(cipherAEAD cipher.AEAD, blockSize int, mode Mode) abstractAEADWrapper {
        plainBlockSize := blockSize * blockSizeTimes
        return abstractAEADWrapper{
                AEAD:            cipherAEAD,
                overheadSize:    cipherAEAD.Overhead(),
                nonceSize:       cipherAEAD.NonceSize(),
                blockSize:       blockSize,
                plainBlockSize:  plainBlockSize,
                cipherBlockSize: cipherAEAD.NonceSize() + cipherAEAD.Overhead() + plainBlockSize,
                sealedSize:      cipherAEAD.Overhead() + plainBlockSize,
                mode:            mode,
        }
}

func @54:8

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/encrypt.go:

func() {
                for _, cb := range defers {
                        cb()
                }
        }

func enc.Close

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/encrypt.go:

func (e *enc) Close() (err error) {
        defer func() {
                utils.CloseAnyway(e.w)
                if e.cb != nil {
                        e.cb()
                }
        }()

        return e.Flush()
}

func @36:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/block_mode_wrapper.go:

36	`func(o *blockModeOption) {`
37	`o.mode = mode`
38	`o.blockMode = bm`
39	`}`

func @43:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/block_mode_wrapper.go:

43	`func(o *blockModeOption) {`
44	`o.mode = mode`
45	`o.stream = stream`
46	`}`

func Mode.NeedIV

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/mode_enum.go:

57	`func (m Mode) NeedIV() bool {`
58	`return ivMode.Contains(m)`
59	`}`

func wrapStream

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/block_mode_wrapper.go:

func wrapStream(stream cipher.Stream, mode Mode) utils.OptionFunc[blockModeOption] {
        return func(o *blockModeOption) {
                o.mode = mode
                o.stream = stream
        }
}

func blockModeWrapper.CipherMode

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/block_mode_wrapper.go:

72	`func (b *blockModeWrapper) CipherMode() Mode { return b.mode }`

func blockModeWrapper.PlainBlockSize

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/block_mode_wrapper.go:

73	`func (b *blockModeWrapper) PlainBlockSize() int { return b.blockSize }`

func wrapBlockMode

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/block_mode_wrapper.go:

func wrapBlockMode(bm cipher.BlockMode, mode Mode) utils.OptionFunc[blockModeOption] {
        return func(o *blockModeOption) {
                o.mode = mode
                o.blockMode = bm
        }
}

func @74:12

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/types.go:

func(b cipher.Block, iv []byte) (e blockMode, err error) {
                        return wrapErr(newBlockModeWrapper(
                                wrapBlock(b, ModeECB, false)),
                        )
                }

func @59:12

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/types.go:

func(b cipher.Block, iv []byte) (e blockMode, err error) {
                        return wrapErr(newBlockModeWrapper(
                                wrapStream(cipher.NewOFB(b, iv), ModeOFB)),
                        )
                }

func @54:12

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/types.go:

func(b cipher.Block, iv []byte) (e blockMode, err error) {
                        return wrapErr(newBlockModeWrapper(
                                wrapStream(cipher.NewCTR(b, iv), ModeCTR)),
                        )
                }

func @49:12

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/types.go:

func(b cipher.Block, iv []byte) (e blockMode, err error) {
                        return wrapErr(newBlockModeWrapper(
                                wrapStream(cipher.NewCFBEncrypter(b, iv), ModeCFB)),
                        )
                }

func @35:23

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/decrypt.go:

35	`func() { fn = NewDecFunc(algo, mode, key, iv) }`

func blockModeWrapper.CipherBlockSize

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/block_mode_wrapper.go:

74	`func (b *blockModeWrapper) CipherBlockSize() int { return b.blockSize }`

func @44:12

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/types.go:

func(b cipher.Block, iv []byte) (e blockMode, err error) {
                        return wrapErr(newBlockModeWrapper(
                                wrapBlockMode(cipher.NewCBCEncrypter(b, iv), ModeCBC)),
                        )
                }

func @39:12

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/types.go:

func(b cipher.Block, iv []byte) (e blockMode, err error) {
                        return wrapErr(newBlockModeWrapper(
                                wrapBlock(b, ModeECB, true)),
                        )
                }

func @35:18

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/types.go:

35	`func(key []byte) (cipher.Block, error) { return sm4.NewCipher(key) }`

func wrapBlock

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/block_mode_wrapper.go:

func wrapBlock(block cipher.Block, mode Mode, isEncoder bool) utils.OptionFunc[blockModeOption] {
        return func(o *blockModeOption) {
                o.mode = mode
                o.block = block
                o.isEncoder = isEncoder
        }
}

func @165:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/decrypt.go:

func(r io.Reader) io.ReadCloser {
                return &dec{
                        bm:        bm,
                        r:         r,
                        buf:       buf,
                        cb:        cb,
                        n:         0,
                        end:       0,
                        size:      size,
                        eof:       false,
                        unsealed:  unsealed,
                        unsealBuf: unsealBuf,
                }
        }

func Mode.IsValid

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/mode_enum.go:

49	`func (m Mode) IsValid() bool {`
50	`return modeEnum.IsValid(m)`
51	`}`

func @79:12

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/types.go:

func(b cipher.Block, iv []byte) (bm blockMode, err error) {
                        return wrapErr(newBlockModeWrapper(
                                wrapBlockMode(cipher.NewCBCDecrypter(b, iv), ModeCBC)),
                        )
                }

func @34:18

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/types.go:

34	`func(key []byte) (cipher.Block, error) { return aes.NewCipher(key) }`

func Algorithm.String

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/algorithm_enum.go:

41	`func (e Algorithm) String() string {`
42	`return algorithmEnum.String(e)`
43	`}`

func @89:12

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/types.go:

func(b cipher.Block, iv []byte) (bm blockMode, err error) {
                        return wrapErr(newBlockModeWrapper(
                                wrapStream(cipher.NewCTR(b, iv), ModeCTR)),
                        )
                }

func @31:23

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/encrypt.go:

31	`func() { fn = NewEncFunc(algo, mode, key, iv) }`

func newAEADDecryptWrapper

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/aead_wrapper.go:

75	`func newAEADDecryptWrapper(cipherAEAD cipher.AEAD, blockSize int, mode Mode) blockMode {`
76	`return &aeadDecryptWrapper{abstractAEADWrapper: newAbstractAEADWrapper(cipherAEAD, blockSize, mode)}`
77	`}`

func @33:18

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/types.go:

33	`func(key []byte) (cipher.Block, error) { return des.NewTripleDESCipher(key) }`

func @94:12

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/types.go:

func(b cipher.Block, iv []byte) (bm blockMode, err error) {
                        return wrapErr(newBlockModeWrapper(
                                wrapStream(cipher.NewOFB(b, iv), ModeOFB)),
                        )
                }

func @32:18

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/types.go:

32	`func(key []byte) (cipher.Block, error) { return des.NewCipher(key) }`

func Algorithm.IsValid

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/algorithm_enum.go:

45	`func (e Algorithm) IsValid() bool {`
46	`return algorithmEnum.IsValid(e)`
47	`}`

func newAEADEncryptWrapper

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/aead_wrapper.go:

49	`func newAEADEncryptWrapper(cipherAEAD cipher.AEAD, blockSize int, mode Mode) blockMode {`
50	`return &aeadEncryptWrapper{abstractAEADWrapper: newAbstractAEADWrapper(cipherAEAD, blockSize, mode)}`
51	`}`

func @162:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/encrypt.go:

func(w io.Writer) io.WriteCloser {
                return &enc{
                        bm:      bm,
                        w:       w,
                        n:       0,
                        buf:     buf,
                        cb:      cb,
                        sealed:  sealed,
                        sealBuf: sealBuf,
                }
        }

func rc4Wrapper.CipherBlockSize

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/rc4_wrapper.go:

11	`func (r *rc4Wrapper) CipherBlockSize() int { return 0 }`

func rc4Wrapper.PlainBlockSize

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/rc4_wrapper.go:

10	`func (r *rc4Wrapper) PlainBlockSize() int { return 0 }`

func abstractAEADWrapper.CipherMode

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/aead_wrapper.go:

43	`func (a *abstractAEADWrapper) CipherMode() Mode { return a.mode }`

func abstractAEADWrapper.CipherBlockSize

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/aead_wrapper.go:

42	`func (a *abstractAEADWrapper) CipherBlockSize() int { return a.cipherBlockSize }`

func abstractAEADWrapper.PlainBlockSize

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/aead_wrapper.go:

41	`func (a *abstractAEADWrapper) PlainBlockSize() int { return a.plainBlockSize }`

func rc4Wrapper.CipherMode

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/rc4_wrapper.go:

9	`func (r *rc4Wrapper) CipherMode() Mode { return modeStream }`

func Mode.String

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/mode_enum.go:

45	`func (m Mode) String() string {`
46	`return modeEnum.String(m)`
47	`}`

func Mode.SupportStream

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/mode_enum.go:

61	`func (m Mode) SupportStream() bool {`
62	`return streamMode.Contains(m)`
63	`}`

func Mode.ShouldPadding

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/mode_enum.go:

53	`func (m Mode) ShouldPadding() bool {`
54	`return paddingMode.Contains(m)`
55	`}`

func @84:12

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/types.go:

func(b cipher.Block, iv []byte) (bm blockMode, err error) {
                        return wrapErr(newBlockModeWrapper(
                                wrapStream(cipher.NewCFBDecrypter(b, iv), ModeCFB)),
                        )
                }

func encrypt

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/encrypt.go:

func encrypt(bm blockMode, src []byte) (dst []byte, err error) {
        plainBlockSize := bm.PlainBlockSize()
        cipherBlockSize := bm.CipherBlockSize()
        defers := make([]func(), 0, 3)
        defer func() {
                for _, cb := range defers {
                        cb()
                }
        }()

        w, cb := utils.BytesBufferPool.Get(nil)
        defers = append(defers, cb)

        if plainBlockSize != 0 && cipherBlockSize != 0 {
                w.Grow((len(src) / plainBlockSize) * cipherBlockSize)
        } else {
                plainBlockSize, cipherBlockSize = len(src), len(src)
                w.Grow(cipherBlockSize)
        }

        sealed, cb := utils.BytesPool.Get(cipherBlockSize)
        defers = append(defers, cb)

        buf, cb := utils.BytesPool.Get(plainBlockSize)
        defers = append(defers, cb)

        var n, blockSize int
        for len(src) > 0 {
                blockSize = utils.Min(plainBlockSize, len(src))
                n, err = bm.CryptBlocks(sealed[:cipherBlockSize], src[:blockSize], buf)
                if err != nil {
                        return
                }
                if _, err = w.Write(sealed[:n]); err != nil {
                        return
                }
                src = src[blockSize:]
        }

        bs := w.Bytes()
        dst = make([]byte, len(bs))
        copy(dst, bs)
        return
}

func decrypt

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/decrypt.go:

func decrypt(bm blockMode, src []byte) (dst []byte, err error) {
        plainBlockSize := bm.PlainBlockSize()
        cipherBlockSize := bm.CipherBlockSize()
        defers := make([]func(), 0, 3)

        w, cb := utils.BytesBufferPool.Get(nil)
        defers = append(defers, cb)

        if plainBlockSize != 0 && cipherBlockSize != 0 {
                w.Grow((len(src) / cipherBlockSize) * plainBlockSize)
        } else {
                plainBlockSize, cipherBlockSize = len(src), len(src)
                w.Grow(plainBlockSize)
        }

        unsealed, cb := utils.BytesPool.Get(plainBlockSize)
        defers = append(defers, cb)

        buf, cb := utils.BytesPool.Get(plainBlockSize)
        defers = append(defers, cb)

        var n, blockSize int
        for len(src) > 0 {
                blockSize = utils.Min(cipherBlockSize, len(src))
                n, err = bm.CryptBlocks(unsealed[:plainBlockSize], src[:blockSize], buf)
                if err != nil {
                        return
                }
                if _, err = w.Write(unsealed[:n]); err != nil {
                        return
                }
                src = src[blockSize:]
        }

        bs := w.Bytes()
        dst = make([]byte, len(bs))
        copy(dst, bs)
        return
}

func NewEncFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/encrypt.go:

func NewEncFunc(algo Algorithm, mode Mode, key, iv []byte) func(w io.Writer) io.WriteCloser {
        bm, err := getEncrypter(algo, mode, key, iv)
        if err != nil {
                panic(err)
        }
        if !bm.CipherMode().SupportStream() {
                panic(ErrNotSupportStream)
        }

        var (
                buf, sealed, sealBuf []byte
                cb                   func()
        )
        if bm.PlainBlockSize() > 0 {
                var bcb, scb, sbcb func()
                buf, bcb = utils.BytesPool.Get(bm.PlainBlockSize())
                sealed, scb = utils.BytesPool.Get(bm.CipherBlockSize())
                sealBuf, sbcb = utils.BytesPool.Get(bm.PlainBlockSize())
                cb = func() { bcb(); scb(); sbcb() }
        }

        return func(w io.Writer) io.WriteCloser {
                return &enc{
                        bm:      bm,
                        w:       w,
                        n:       0,
                        buf:     buf,
                        cb:      cb,
                        sealed:  sealed,
                        sealBuf: sealBuf,
                }
        }
}

func dec.Read

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/decrypt.go:

func (d *dec) Read(p []byte) (n int, err error) {
        var (
                nr, nc int
                dst    []byte
        )

        if d.buf == nil {
                n, err = d.r.Read(p)
                d.eof = errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF)
                if err != nil && !d.eof {
                        return
                }
                dst, err = decrypt(d.bm, p[:n])
                if err != nil {
                        return
                }
                n = copy(p[:len(dst)], dst)
                if d.eof {
                        err = io.EOF
                }
                return
        }

        for len(p) > 0 {
                // read from buffer
                if length := d.end - d.n; length > 0 {
                        copied := utils.Min(length, len(p))
                        n += copy(p[:copied], d.buf[d.n:d.n+copied])
                        d.n += copied
                        p = p[copied:]
                        continue
                }

                // buffer is empty, write new buffer
                if d.eof {
                        return n, io.EOF
                }
                d.n = 0
                d.end = 0
                for {
                        nr, err = d.r.Read(d.buf[d.n:d.size])
                        d.eof = errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF)
                        if err != nil && !d.eof {
                                return
                        }

                        d.n += nr
                        if d.n < d.size && !d.eof {
                                continue
                        }

                        nc, err = d.bm.CryptBlocks(d.unsealed, d.buf[:d.n], d.unsealBuf)
                        if err != nil {
                                return
                        }

                        d.end += copy(d.buf[:nc], d.unsealed[:nc])
                        d.n = 0
                        break
                }
        }

        return
}

func enc.Write

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/encrypt.go:

func (e *enc) Write(p []byte) (n int, err error) {
        if e.buf == nil {
                var dst []byte
                dst, err = encrypt(e.bm, p)
                if err != nil {
                        return
                }
                n = len(p)
                _, err = e.w.Write(dst)
                return
        }

        written := 0
        for len(p) > 0 {
                nCopy := utils.Min(len(p), len(e.buf)-e.n)
                copy(e.buf[e.n:], p[:nCopy])
                e.n += nCopy
                written += nCopy
                p = p[nCopy:]

                if e.n == len(e.buf) {
                        if err = e.flush(); err != nil {
                                return written, err
                        }
                }
        }

        return written, nil
}

func NewDecFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/decrypt.go:

func NewDecFunc(algo Algorithm, mode Mode, key, iv []byte) func(r io.Reader) io.ReadCloser {
        bm, err := getDecrypter(algo, mode, key, iv)
        if err != nil {
                panic(err)
        }
        if !bm.CipherMode().SupportStream() {
                panic(ErrNotSupportStream)
        }

        var (
                buf, unsealed, unsealBuf []byte
                cb                       func()
                size                     int
        )

        if size = bm.CipherBlockSize(); size > 0 {
                var bcb, ucb, ubcb func()
                buf, bcb = utils.BytesPool.Get(size)
                unsealed, ucb = utils.BytesPool.Get(bm.PlainBlockSize())
                unsealBuf, ubcb = utils.BytesPool.Get(bm.PlainBlockSize())
                cb = func() { bcb(); ucb(); ubcb() }
        }

        return func(r io.Reader) io.ReadCloser {
                return &dec{
                        bm:        bm,
                        r:         r,
                        buf:       buf,
                        cb:        cb,
                        n:         0,
                        end:       0,
                        size:      size,
                        eof:       false,
                        unsealed:  unsealed,
                        unsealBuf: unsealBuf,
                }
        }
}

func @19:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/decrypt.go:

func(src []byte) (dst []byte, err error) {
                dst, err = decrypt(bm, src)
                if err != nil {
                        return
                }
                if mode.ShouldPadding() {
                        dst, err = PKCS7Unpad(dst)
                }
                return
        }

func DecryptStreamFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/decrypt.go:

func DecryptStreamFunc(algo Algorithm, mode Mode, key, iv []byte) (
        dec func(dst io.Writer, src io.Reader) (err error), err error) {
        var fn func(src io.Reader) io.ReadCloser

        _, err = utils.Catch(func() { fn = NewDecFunc(algo, mode, key, iv) })
        if err != nil {
                return
        }

        dec = func(dst io.Writer, src io.Reader) (err error) {
                buf, cb := utils.BytesPool.Get(defaultBlockSize * blockSizeTimes)
                defer cb()

                wrapper := fn(src)
                defer utils.CloseAnyway(wrapper)
                _, err = io.CopyBuffer(dst, wrapper, buf)
                return
        }

        return
}

func EncryptBytesFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/encrypt.go:

func EncryptBytesFunc(algo Algorithm, mode Mode, key, iv []byte) (
        enc func(src []byte) (dst []byte, err error), err error) {
        bm, err := getEncrypter(algo, mode, key, iv)
        if err != nil {
                return
        }
        mode = bm.CipherMode()
        plainBlockSize := bm.PlainBlockSize()
        return func(src []byte) (dst []byte, err error) {
                if mode.ShouldPadding() {
                        src = PKCS7Pad(src, plainBlockSize)
                }
                return encrypt(bm, src)
        }, err
}

func blockModeWrapper.CryptBlocks

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/block_mode_wrapper.go:

func (b *blockModeWrapper) CryptBlocks(dst, src, buf []byte) (n int, err error) {
        if len(src) == 0 {
                return
        }
        n = len(src)
        switch {
        case b.blockMode != nil:
                b.blockMode.CryptBlocks(dst, src)
        case b.block != nil:
                if b.isEncoder {
                        b.block.Encrypt(dst, src)
                } else {
                        b.block.Decrypt(dst, src)
                }
        case b.stream != nil:
                b.stream.XORKeyStream(dst, src)
        default:
                copy(dst, src)
        }
        return
}

func aeadEncryptWrapper.CryptBlocks

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/aead_wrapper.go:

func (a *aeadEncryptWrapper) CryptBlocks(dst, src, buf []byte) (n int, err error) {
        if len(src) == 0 {
                return
        }

        nonce, cb := utils.BytesPool.Get(a.nonceSize)
        defer cb()
        if _, err = utils.CryptoRandom(nonce); err != nil {
                return
        }

        sealed := a.Seal(buf[:0], nonce, src[:utils.Min(a.plainBlockSize, len(src))], nil)
        copy(dst[:a.nonceSize], nonce)
        copy(dst[a.nonceSize:], sealed)
        n = len(nonce) + len(sealed)
        return
}

func @126:31

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/types.go:

func(key []byte) (bm blockMode, err error) {
                        cipherAEAD, err := chacha20poly1305.NewX(key)
                        if err != nil {
                                return
                        }
                        bm = newAEADEncryptWrapper(cipherAEAD, defaultBlockSize, modeStream)
                        return
                }

func @136:17

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/types.go:

func(key []byte) (bm blockMode, err error) {
                        cipher, err := rc4.NewCipher(key)
                        if err != nil {
                                return
                        }
                        bm = &rc4Wrapper{rc: cipher}
                        return
                }

func @118:30

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/types.go:

func(key []byte) (bm blockMode, err error) {
                        cipherAEAD, err := chacha20poly1305.New(key)
                        if err != nil {
                                return
                        }
                        bm = newAEADEncryptWrapper(cipherAEAD, defaultBlockSize, modeStream)
                        return
                }

func @144:30

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/types.go:

func(key []byte) (bm blockMode, err error) {
                        cipherAEAD, err := chacha20poly1305.New(key)
                        if err != nil {
                                return
                        }
                        bm = newAEADDecryptWrapper(cipherAEAD, defaultBlockSize, modeStream)
                        return
                }

func @110:17

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/types.go:

func(key []byte) (bm blockMode, err error) {
                        cipher, err := rc4.NewCipher(key)
                        if err != nil {
                                return
                        }
                        bm = &rc4Wrapper{rc: cipher}
                        return
                }

func DecryptBytesFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/decrypt.go:

func DecryptBytesFunc(algo Algorithm, mode Mode, key, iv []byte) (
        enc func(src []byte) (dst []byte, err error), err error) {
        bm, err := getDecrypter(algo, mode, key, iv)
        if err != nil {
                return
        }
        mode = bm.CipherMode()
        return func(src []byte) (dst []byte, err error) {
                dst, err = decrypt(bm, src)
                if err != nil {
                        return
                }
                if mode.ShouldPadding() {
                        dst, err = PKCS7Unpad(dst)
                }
                return
        }, err
}

func rc4Wrapper.CryptBlocks

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/rc4_wrapper.go:

func (r *rc4Wrapper) CryptBlocks(dst, src, buf []byte) (n int, err error) {
        if len(src) == 0 {
                return
        }
        r.rc.XORKeyStream(dst, src)
        n = len(src)
        return
}

func @152:31

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/types.go:

func(key []byte) (bm blockMode, err error) {
                        cipherAEAD, err := chacha20poly1305.NewX(key)
                        if err != nil {
                                return
                        }
                        bm = newAEADDecryptWrapper(cipherAEAD, defaultBlockSize, modeStream)
                        return
                }

func @99:12

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/types.go:

func(b cipher.Block, iv []byte) (bm blockMode, err error) {
                        cipherAEAD, err := cipher.NewGCM(b)
                        if err != nil {
                                return
                        }
                        bm = newAEADDecryptWrapper(cipherAEAD, b.BlockSize(), ModeGCM)
                        return
                }

func @64:12

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/types.go:

func(b cipher.Block, iv []byte) (e blockMode, err error) {
                        aead, err := cipher.NewGCM(b)
                        if err != nil {
                                return
                        }
                        e = newAEADEncryptWrapper(aead, b.BlockSize(), ModeGCM)
                        return
                }

func aeadDecryptWrapper.CryptBlocks

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/aead_wrapper.go:

func (a *aeadDecryptWrapper) CryptBlocks(dst, src, buf []byte) (n int, err error) {
        if len(src) == 0 {
                return
        }
        sealedSize := utils.Min(a.sealedSize, len(src)-a.nonceSize)
        if sealedSize < 0 {
                return 0, errors.New("input not full blocks when decrypt")
        }

        nonce := src[:a.nonceSize]
        src = src[a.nonceSize:]
        unsealed, err := a.Open(buf[:0], nonce, src[:sealedSize], nil)
        if err != nil {
                return
        }

        copy(dst, unsealed)
        n = len(unsealed)
        return
}

func PKCS7Pad

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/padding.go:

func PKCS7Pad(data []byte, blockSize int) []byte {
        if blockSize == 0 {
                return data
        }
        padding := blockSize - len(data)%blockSize
        return append(data, bytes.Repeat([]byte{byte(padding)}, padding)...)
}

func getEncrypter

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/encrypt.go:

func getEncrypter(algo Algorithm, mode Mode, key, iv []byte) (bm blockMode, err error) {
        if blockMapping, ok := cipherBlockMapping[algo]; ok {
                var cipherBlock cipher.Block
                cipherBlock, err = blockMapping(key)
                if err != nil {
                        return
                }
                modeMapping, ok := encryptModeMapping[mode]
                if !ok {
                        return nil, fmt.Errorf("unknown cipher mode %+v", mode)
                }
                bm, err = modeMapping(cipherBlock, iv)
                if err != nil {
                        return
                }
        }

        // stream
        if bm == nil {
                blockMapping, ok := streamEncryptMapping[algo]
                if !ok {
                        return nil, fmt.Errorf("unknown cipher algorithm %+v", algo)
                }
                if bm, err = blockMapping(key); err != nil {
                        return
                }
        }

        if bm == nil {
                return nil, fmt.Errorf("unknown cipher algorithm(%+v) or mode(%+v)", algo, mode)
        }

        return
}

func getDecrypter

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/decrypt.go:

func getDecrypter(algo Algorithm, mode Mode, key, iv []byte) (bm blockMode, err error) {
        if blockMapping, ok := cipherBlockMapping[algo]; ok {
                var cipherBlock cipher.Block
                cipherBlock, err = blockMapping(key)
                if err != nil {
                        return
                }
                modeMapping, ok := decryptModeMapping[mode]
                if !ok {
                        return nil, fmt.Errorf("unknown cipher mode %+v", mode)
                }
                bm, err = modeMapping(cipherBlock, iv)
                if err != nil {
                        return
                }
        }

        // stream
        if bm == nil {
                blockMapping, ok := streamDecryptMapping[algo]
                if !ok {
                        return nil, fmt.Errorf("unknown cipher algorithm %+v", algo)
                }
                if bm, err = blockMapping(key); err != nil {
                        return
                }
        }

        if bm == nil {
                return nil, fmt.Errorf("unknown cipher algorithm(%+v) or mode(%+v)", algo, mode)
        }

        return
}

func enc.flush

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/encrypt.go:

func (e *enc) flush() (err error) {
        if e.buf == nil {
                return
        }

        n, err := e.bm.CryptBlocks(e.sealed, e.buf[:e.n], e.sealBuf)
        if err != nil {
                return
        }

        _, err = e.w.Write(e.sealed[:n])
        if err != nil {
                return err
        }

        e.n = 0
        return
}

func PKCS7Unpad

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/padding.go:

func PKCS7Unpad(data []byte) ([]byte, error) {
        length := len(data)
        if length == 0 {
                return data, nil
        }
        padding := int(data[length-1])
        if padding == 0 || padding > len(data) {
                return data, errors.New("invalid pkcs7 padding (padding size > data)")
        }
        for i := 1; i < padding; i++ {
                if data[length-1-i] != byte(padding) {
                        return data, errors.New("invalid pkcs7 padding (pad[i] != padding text)")
                }
        }

        return data[:(length - padding)], nil
}

func ParseMode

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/mode_enum.go:

func ParseMode(s any) Mode {
        switch v := s.(type) {
        case string:
                if enumList := modeEnum.Enum(v); len(enumList) > 0 {
                        return enumList[0]
                }
        case Mode:
                return v
        default:
                return Mode(cast.ToInt(s))
        }
        return ModeUnknown
}

func ParseAlgorithm

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/algorithm_enum.go:

func ParseAlgorithm(s any) Algorithm {
        switch v := s.(type) {
        case string:
                if enumList := algorithmEnum.Enum(v); len(enumList) > 0 {
                        return enumList[0]
                }
        case Algorithm:
                return v
        default:
                return Algorithm(cast.ToInt(s))
        }
        return AlgorithmUnknown
}

func Algorithm.Value

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/algorithm_enum.go:

37	`func (e Algorithm) Value() uint8 {`
38	`return uint8(e)`
39	`}`

func Mode.Value

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cipher/mode_enum.go:

41	`func (m Mode) Value() uint8 {`
42	`return uint8(m)`
43	`}`

Package Overview: github.com/wfusion/gofusion/common/utils/clone 37.3%

Please select a function to see what's left for testing.

`init(...)`	`github.com/wfusion/gofusion/common/utils/clone/structtype.go`	`100.0%`	`14/14`
`Allocator.lookupStructType(...)`	`github.com/wfusion/gofusion/common/utils/clone/allocator.go`	`100.0%`	`9/9`
`SliceComparable(...)`	`github.com/wfusion/gofusion/common/utils/clone/base.go`	`100.0%`	`5/5`
`cloneState.cloneInterface(...)`	`github.com/wfusion/gofusion/common/utils/clone/clone.go`	`100.0%`	`5/5`
`cloneState.cloneStruct(...)`	`github.com/wfusion/gofusion/common/utils/clone/clone.go`	`100.0%`	`4/4`
`IsScalar(...)`	`github.com/wfusion/gofusion/common/utils/clone/structtype.go`	`100.0%`	`4/4`
`Allocator.MarkAsOpaquePointer(...)`	`github.com/wfusion/gofusion/common/utils/clone/allocator.go`	`100.0%`	`3/3`
`cloneState.cloneArray(...)`	`github.com/wfusion/gofusion/common/utils/clone/clone.go`	`100.0%`	`3/3`
`parseReflectValue(...)`	`github.com/wfusion/gofusion/common/utils/clone/interfacedata.go`	`100.0%`	`3/3`
`MakeCloner(...)`	`github.com/wfusion/gofusion/common/utils/clone/cloner.go`	`100.0%`	`1/1`
`SetCustomFunc(...)`	`github.com/wfusion/gofusion/common/utils/clone/api_go118.go`	`100.0%`	`1/1`
`structType.CanShadowCopy(...)`	`github.com/wfusion/gofusion/common/utils/clone/structtype.go`	`100.0%`	`1/1`
`MarkAsScalar(...)`	`github.com/wfusion/gofusion/common/utils/clone/api_go118.go`	`100.0%`	`1/1`
`Allocator.MakeMap(...)`	`github.com/wfusion/gofusion/common/utils/clone/allocator.go`	`100.0%`	`1/1`
`Allocator.MakeSlice(...)`	`github.com/wfusion/gofusion/common/utils/clone/allocator.go`	`100.0%`	`1/1`
`Slowly(...)`	`github.com/wfusion/gofusion/common/utils/clone/api_go118.go`	`100.0%`	`1/1`
`heapNew(...)`	`github.com/wfusion/gofusion/common/utils/clone/allocator.go`	`100.0%`	`1/1`
`heapMakeSlice(...)`	`github.com/wfusion/gofusion/common/utils/clone/allocator.go`	`100.0%`	`1/1`
`heapMakeMap(...)`	`github.com/wfusion/gofusion/common/utils/clone/allocator.go`	`100.0%`	`1/1`
`setCustomFunc(...)`	`github.com/wfusion/gofusion/common/utils/clone/structtype.go`	`100.0%`	`1/1`
`markAsOpaquePointer(...)`	`github.com/wfusion/gofusion/common/utils/clone/structtype.go`	`100.0%`	`1/1`
`markAsScalar(...)`	`github.com/wfusion/gofusion/common/utils/clone/structtype.go`	`100.0%`	`1/1`
`Allocator.New(...)`	`github.com/wfusion/gofusion/common/utils/clone/allocator.go`	`100.0%`	`1/1`
`mapIter(...)`	`github.com/wfusion/gofusion/common/utils/clone/mapiter_go112.go`	`100.0%`	`1/1`
`Clone(...)`	`github.com/wfusion/gofusion/common/utils/clone/api_go118.go`	`100.0%`	`1/1`
`Cloner.CloneSlowly(...)`	`github.com/wfusion/gofusion/common/utils/clone/cloner.go`	`100.0%`	`1/1`
`Cloner.Clone(...)`	`github.com/wfusion/gofusion/common/utils/clone/cloner.go`	`100.0%`	`1/1`
`MarkAsOpaquePointer(...)`	`github.com/wfusion/gofusion/common/utils/clone/api_go118.go`	`100.0%`	`1/1`
`cloneState.cloneSlice(...)`	`github.com/wfusion/gofusion/common/utils/clone/clone.go`	`95.7%`	`22/23`
`cloneState.copyStruct(...)`	`github.com/wfusion/gofusion/common/utils/clone/clone.go`	`94.7%`	`18/19`
`cloneState.cloneMap(...)`	`github.com/wfusion/gofusion/common/utils/clone/clone.go`	`93.8%`	`15/16`
`init(...)`	`github.com/wfusion/gofusion/common/utils/clone/interfacedata.go`	`90.9%`	`10/11`
`Allocator.loadStructType(...)`	`github.com/wfusion/gofusion/common/utils/clone/allocator.go`	`85.3%`	`29/34`
`Allocator.isOpaquePointer(...)`	`github.com/wfusion/gofusion/common/utils/clone/allocator.go`	`83.3%`	`5/6`
`cloneSlowly(...)`	`github.com/wfusion/gofusion/common/utils/clone/clone.go`	`80.0%`	`4/5`
`clone(...)`	`github.com/wfusion/gofusion/common/utils/clone/clone.go`	`80.0%`	`4/5`
`cloneState.clone(...)`	`github.com/wfusion/gofusion/common/utils/clone/clone.go`	`75.0%`	`9/12`
`cloneState.copyArray(...)`	`github.com/wfusion/gofusion/common/utils/clone/clone.go`	`75.0%`	`6/8`
`Allocator.cloneSlowly(...)`	`github.com/wfusion/gofusion/common/utils/clone/allocator.go`	`75.0%`	`6/8`
`Allocator.MarkAsScalar(...)`	`github.com/wfusion/gofusion/common/utils/clone/allocator.go`	`75.0%`	`3/4`
`cloneState.clonePtr(...)`	`github.com/wfusion/gofusion/common/utils/clone/clone.go`	`72.4%`	`21/29`
`forceClearROFlag(...)`	`github.com/wfusion/gofusion/common/utils/clone/structtype.go`	`69.2%`	`9/13`
`Allocator.clone(...)`	`github.com/wfusion/gofusion/common/utils/clone/allocator.go`	`66.7%`	`4/6`
`Allocator.SetCustomFunc(...)`	`github.com/wfusion/gofusion/common/utils/clone/allocator.go`	`57.1%`	`4/7`
`structType.Init(...)`	`github.com/wfusion/gofusion/common/utils/clone/structtype.go`	`54.5%`	`6/11`
`shadowCopy(...)`	`github.com/wfusion/gofusion/common/utils/clone/clone.go`	`50.0%`	`28/56`
`cloneState.fix(...)`	`github.com/wfusion/gofusion/common/utils/clone/clone.go`	`50.0%`	`2/4`
`copyScalarValue(...)`	`github.com/wfusion/gofusion/common/utils/clone/structtype.go`	`26.9%`	`7/26`
`fixState.fixMap(...)`	`github.com/wfusion/gofusion/common/utils/clone/clone.go`	`0.0%`	`0/46`
`fixState.fixStruct(...)`	`github.com/wfusion/gofusion/common/utils/clone/clone.go`	`0.0%`	`0/32`
`fixState.fixArray(...)`	`github.com/wfusion/gofusion/common/utils/clone/clone.go`	`0.0%`	`0/29`
`fixState.fixSlice(...)`	`github.com/wfusion/gofusion/common/utils/clone/clone.go`	`0.0%`	`0/29`
`wrap(...)`	`github.com/wfusion/gofusion/common/utils/clone/wrapper.go`	`0.0%`	`0/24`
`newAllocator(...)`	`github.com/wfusion/gofusion/common/utils/clone/allocator.go`	`0.0%`	`0/15`
`fixState.fixInterface(...)`	`github.com/wfusion/gofusion/common/utils/clone/clone.go`	`0.0%`	`0/15`
`fixState.fix(...)`	`github.com/wfusion/gofusion/common/utils/clone/clone.go`	`0.0%`	`0/12`
`fixState.fixPtr(...)`	`github.com/wfusion/gofusion/common/utils/clone/clone.go`	`0.0%`	`0/11`
`cloneState.cloneString(...)`	`github.com/wfusion/gofusion/common/utils/clone/clone.go`	`0.0%`	`0/10`
`forceSetMapIndex(...)`	`github.com/wfusion/gofusion/common/utils/clone/clone.go`	`0.0%`	`0/9`
`undo(...)`	`github.com/wfusion/gofusion/common/utils/clone/wrapper.go`	`0.0%`	`0/8`
`AllocatorMethods.makeChan(...)`	`github.com/wfusion/gofusion/common/utils/clone/allocatormethods.go`	`0.0%`	`0/7`
`@90:48(...)`	`github.com/wfusion/gofusion/common/utils/clone/structtype.go`	`0.0%`	`0/7`
`AllocatorMethods.new(...)`	`github.com/wfusion/gofusion/common/utils/clone/allocatormethods.go`	`0.0%`	`0/7`
`unwrap(...)`	`github.com/wfusion/gofusion/common/utils/clone/wrapper.go`	`0.0%`	`0/7`
`AllocatorMethods.makeMap(...)`	`github.com/wfusion/gofusion/common/utils/clone/allocatormethods.go`	`0.0%`	`0/7`
`AllocatorMethods.makeSlice(...)`	`github.com/wfusion/gofusion/common/utils/clone/allocatormethods.go`	`0.0%`	`0/7`
`isWrapped(...)`	`github.com/wfusion/gofusion/common/utils/clone/wrapper.go`	`0.0%`	`0/6`
`origin(...)`	`github.com/wfusion/gofusion/common/utils/clone/wrapper.go`	`0.0%`	`0/6`
`Map(...)`	`github.com/wfusion/gofusion/common/utils/clone/base.go`	`0.0%`	`0/6`
`Slice(...)`	`github.com/wfusion/gofusion/common/utils/clone/base.go`	`0.0%`	`0/6`
`@75:44(...)`	`github.com/wfusion/gofusion/common/utils/clone/structtype.go`	`0.0%`	`0/5`
`DecimalPtr(...)`	`github.com/wfusion/gofusion/common/utils/clone/base.go`	`0.0%`	`0/5`
`ComparablePtr(...)`	`github.com/wfusion/gofusion/common/utils/clone/base.go`	`0.0%`	`0/5`
`AllocatorMethods.isScalar(...)`	`github.com/wfusion/gofusion/common/utils/clone/allocatormethods.go`	`0.0%`	`0/5`
`validateChecksum(...)`	`github.com/wfusion/gofusion/common/utils/clone/wrapper.go`	`0.0%`	`0/5`
`SliceComparablePtr(...)`	`github.com/wfusion/gofusion/common/utils/clone/base.go`	`0.0%`	`0/5`
`TimePtr(...)`	`github.com/wfusion/gofusion/common/utils/clone/base.go`	`0.0%`	`0/5`
`makeChecksum(...)`	`github.com/wfusion/gofusion/common/utils/clone/wrapper.go`	`0.0%`	`0/4`
`TimeLocationPtr(...)`	`github.com/wfusion/gofusion/common/utils/clone/base.go`	`0.0%`	`0/4`
`@83:16(...)`	`github.com/wfusion/gofusion/common/utils/clone/structtype.go`	`0.0%`	`0/4`
`AllocatorMethods.parent(...)`	`github.com/wfusion/gofusion/common/utils/clone/allocatormethods.go`	`0.0%`	`0/3`
`@69:45(...)`	`github.com/wfusion/gofusion/common/utils/clone/structtype.go`	`0.0%`	`0/3`
`@63:45(...)`	`github.com/wfusion/gofusion/common/utils/clone/structtype.go`	`0.0%`	`0/3`
`GormModelPtr(...)`	`github.com/wfusion/gofusion/common/utils/clone/base.go`	`0.0%`	`0/3`
`fixState.new(...)`	`github.com/wfusion/gofusion/common/utils/clone/clone.go`	`0.0%`	`0/1`
`Undo(...)`	`github.com/wfusion/gofusion/common/utils/clone/api_go118.go`	`0.0%`	`0/1`
`Unwrap(...)`	`github.com/wfusion/gofusion/common/utils/clone/api_go118.go`	`0.0%`	`0/1`
`heapMakeChan(...)`	`github.com/wfusion/gofusion/common/utils/clone/allocator.go`	`0.0%`	`0/1`
`Allocator.CloneSlowly(...)`	`github.com/wfusion/gofusion/common/utils/clone/allocator.go`	`0.0%`	`0/1`
`Allocator.Clone(...)`	`github.com/wfusion/gofusion/common/utils/clone/allocator.go`	`0.0%`	`0/1`
`Allocator.MakeChan(...)`	`github.com/wfusion/gofusion/common/utils/clone/allocator.go`	`0.0%`	`0/1`
`NewAllocator(...)`	`github.com/wfusion/gofusion/common/utils/clone/api_go118.go`	`0.0%`	`0/1`
`@42:11(...)`	`github.com/wfusion/gofusion/common/utils/clone/allocatormethods.go`	`0.0%`	`0/1`
`Wrap(...)`	`github.com/wfusion/gofusion/common/utils/clone/api_go118.go`	`0.0%`	`0/1`
`@60:11(...)`	`github.com/wfusion/gofusion/common/utils/clone/allocatormethods.go`	`0.0%`	`0/1`
`@78:11(...)`	`github.com/wfusion/gofusion/common/utils/clone/allocatormethods.go`	`0.0%`	`0/1`
`getOrigin(...)`	`github.com/wfusion/gofusion/common/utils/clone/wrapper.go`	`0.0%`	`0/1`
`@96:11(...)`	`github.com/wfusion/gofusion/common/utils/clone/allocatormethods.go`	`0.0%`	`0/1`
`FromHeap(...)`	`github.com/wfusion/gofusion/common/utils/clone/api_go118.go`	`0.0%`	`0/1`
`fromHeap(...)`	`github.com/wfusion/gofusion/common/utils/clone/allocator.go`	`0.0%`	`0/1`
`emptyCloneFunc(...)`	`github.com/wfusion/gofusion/common/utils/clone/structtype.go`	`100.0%`	`0/0`

func init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/structtype.go:

func init() {
        // Some well-known scalar-like structs.
        MarkAsScalar(reflect.TypeOf(time.Time{}))
        MarkAsScalar(reflect.TypeOf(reflect.Value{}))

        // Special case for elliptic.Curve which is used by TLS ECC certificate.
        // Package crypto/tls uses elliptic.Curve as enum values
        // so that they should be treated as opaque pointers.
        //
        // As elliptic.Curve is an interface, it can be *elliptic.CurveParam or elliptic.p256Curve.
        MarkAsOpaquePointer(reflect.TypeOf(&elliptic.CurveParams{}))
        curves := []elliptic.Curve{
                elliptic.P224(),
                elliptic.P256(),
                elliptic.P384(),
                elliptic.P521(),
        }

        for _, curve := range curves {
                MarkAsOpaquePointer(reflect.ValueOf(curve).Type())
        }

        // Special case for reflect.Type (actually *reflect.rtype):
        // The *reflect.rtype should not be copied as it is immutable and
        // may point to a variable that actual type is not reflect.rtype,
        // e.g. *reflect.arrayType or *reflect.chanType.
        MarkAsOpaquePointer(reflect.TypeOf(reflect.TypeOf(0)))

        // Some well-known no-copy structs.
        //
        // Almost all structs defined in package "sync" and "go.uber.org/atomic" are set
        // except `sync.Once` which can be safely cloned with a correct done value.
        SetCustomFunc(reflect.TypeOf(sync.Mutex{}), emptyCloneFunc)
        SetCustomFunc(reflect.TypeOf(sync.RWMutex{}), emptyCloneFunc)
        SetCustomFunc(reflect.TypeOf(sync.WaitGroup{}), emptyCloneFunc)
        SetCustomFunc(reflect.TypeOf(sync.Cond{}), func(allocator *Allocator, old, new reflect.Value) {
                // Copy the New func from old value.
                oldL := old.FieldByName("L")
                newL := allocator.Clone(oldL)
                new.FieldByName("L").Set(newL)
        })
        SetCustomFunc(reflect.TypeOf(sync.Pool{}), func(allocator *Allocator, old, new reflect.Value) {
                // Copy the New func from old value.
                oldFn := old.FieldByName("New")
                newFn := allocator.Clone(oldFn)
                new.FieldByName("New").Set(newFn)
        })
        SetCustomFunc(reflect.TypeOf(sync.Map{}), func(allocator *Allocator, old, new reflect.Value) {
                if !old.CanAddr() {
                        return
                }

                // Clone all values inside sync.Map.
                oldMap := old.Addr().Interface().(*sync.Map)
                newMap := new.Addr().Interface().(*sync.Map)
                oldMap.Range(func(key, value interface{}) bool {
                        k := clone(allocator, key)
                        v := clone(allocator, value)
                        newMap.Store(k, v)
                        return true
                })
        })
        SetCustomFunc(reflect.TypeOf(atomic.Value{}), func(allocator *Allocator, old, new reflect.Value) {
                if !old.CanAddr() {
                        return
                }

                // Clone value inside atomic.Value.
                oldValue := old.Addr().Interface().(*atomic.Value)
                newValue := new.Addr().Interface().(*atomic.Value)
                v := oldValue.Load()
                cloned := clone(allocator, v)
                newValue.Store(cloned)
        })
}

func Allocator.lookupStructType

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/allocator.go:

func (a *Allocator) lookupStructType(t reflect.Type) (st structType, ok bool) {
        var v interface{}
        current := a

        for current != nil {
                v, ok = current.cachedStructTypes.Load(t)

                if ok {
                        st = v.(structType)
                        return
                }

                current = current.parent
        }

        return
}

func SliceComparable

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/base.go:

func SliceComparable[T comparable, TS ~[]T](s TS) (d TS) {
        if s == nil {
                return
        }
        d = make(TS, len(s), cap(s))
        copy(d, s)
        return
}

func cloneState.cloneInterface

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/clone.go:

func (state *cloneState) cloneInterface(v reflect.Value) reflect.Value {
        if v.IsNil() {
                return reflect.Zero(v.Type())
        }

        t := v.Type()
        elem := v.Elem()
        return state.clone(elem).Convert(elem.Type()).Convert(t)
}

func cloneState.cloneStruct

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/clone.go:

func (state *cloneState) cloneStruct(v reflect.Value) reflect.Value {
        t := v.Type()
        nv := state.allocator.New(t)
        state.copyStruct(v, nv)
        return nv.Elem()
}

func IsScalar

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/structtype.go:

func IsScalar(k reflect.Kind) bool {
        switch k {
        case reflect.Bool,
                reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
                reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr,
                reflect.Float32, reflect.Float64,
                reflect.Complex64, reflect.Complex128,
                reflect.Func,
                reflect.UnsafePointer,
                reflect.Invalid:
                return true

        case reflect.String:
                // If arena is not enabled, string can be copied as scalar safely
                // as it's immutable by design.
                return !arenaIsEnabled
        }

        return false
}

func Allocator.MarkAsOpaquePointer

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/allocator.go:

func (a *Allocator) MarkAsOpaquePointer(t reflect.Type) {
        if t.Kind() != reflect.Ptr {
                return
        }

        a.cachedPointerTypes.Store(t, struct{}{})
}

func cloneState.cloneArray

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/clone.go:

func (state *cloneState) cloneArray(v reflect.Value) reflect.Value {
        dst := state.allocator.New(v.Type())
        state.copyArray(v, dst)
        return dst.Elem()
}

func parseReflectValue

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/interfacedata.go:

func parseReflectValue(v reflect.Value) interfaceData {
        pv := (unsafe.Pointer)(uintptr(unsafe.Pointer(&v)) + reflectValuePtrOffset)
        ptr := *(*unsafe.Pointer)(pv)
        return *(*interfaceData)(ptr)
}

func MakeCloner

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/cloner.go:

func MakeCloner(allocator *Allocator) Cloner {
        return Cloner{
                allocator: allocator,
        }
}

func SetCustomFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/api_go118.go:

97	`func SetCustomFunc(t reflect.Type, fn Func) {`
98	`setCustomFunc(t, fn)`
99	`}`

func structType.CanShadowCopy

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/structtype.go:

172	`func (st *structType) CanShadowCopy() bool {`
173	`return len(st.PointerFields) == 0 && st.fn == nil`
174	`}`

func MarkAsScalar

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/api_go118.go:

89	`func MarkAsScalar(t reflect.Type) {`
90	`markAsScalar(t)`
91	`}`

func Allocator.MakeMap

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/allocator.go:

89	`func (a *Allocator) MakeMap(t reflect.Type, n int) reflect.Value {`
90	`return a.makeMap(a.pool, t, n)`
91	`}`

func Allocator.MakeSlice

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/allocator.go:

84	`func (a *Allocator) MakeSlice(t reflect.Type, len, cap int) reflect.Value {`
85	`return a.makeSlice(a.pool, t, len, cap)`
86	`}`

func Slowly

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/api_go118.go:

35	`func Slowly[T any](t T) T {`
36	`return cloner.CloneSlowly(t).(T)`
37	`}`

func heapNew

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/allocator.go:

300	`func heapNew(pool unsafe.Pointer, t reflect.Type) reflect.Value {`
301	`return reflect.New(t)`
302	`}`

func heapMakeSlice

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/allocator.go:

304	`func heapMakeSlice(pool unsafe.Pointer, t reflect.Type, len, cap int) reflect.Value {`
305	`return reflect.MakeSlice(t, len, cap)`
306	`}`

func heapMakeMap

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/allocator.go:

308	`func heapMakeMap(pool unsafe.Pointer, t reflect.Type, n int) reflect.Value {`
309	`return reflect.MakeMapWithSize(t, n)`
310	`}`

func setCustomFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/structtype.go:

144	`func setCustomFunc(t reflect.Type, fn Func) {`
145	`defaultAllocator.SetCustomFunc(t, fn)`
146	`}`

func markAsOpaquePointer

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/structtype.go:

125	`func markAsOpaquePointer(t reflect.Type) {`
126	`defaultAllocator.MarkAsOpaquePointer(t)`
127	`}`

func markAsScalar

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/structtype.go:

114	`func markAsScalar(t reflect.Type) {`
115	`defaultAllocator.MarkAsScalar(t)`
116	`}`

func Allocator.New

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/allocator.go:

79	`func (a *Allocator) New(t reflect.Type) reflect.Value {`
80	`return a.new(a.pool, t)`
81	`}`

func mapIter

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/mapiter_go112.go:

13	`func mapIter(m reflect.Value) *reflect.MapIter {`
14	`return m.MapRange()`
15	`}`

func Clone

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/api_go118.go:

27	`func Clone[T any](t T) T {`
28	`return cloner.Clone(t).(T)`
29	`}`

func Cloner.CloneSlowly

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/cloner.go:

25	`func (c Cloner) CloneSlowly(v interface{}) interface{} {`
26	`return cloneSlowly(c.allocator, v)`
27	`}`

func Cloner.Clone

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/cloner.go:

19	`func (c Cloner) Clone(v interface{}) interface{} {`
20	`return clone(c.allocator, v)`
21	`}`

func MarkAsOpaquePointer

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/api_go118.go:

75	`func MarkAsOpaquePointer(t reflect.Type) {`
76	`markAsOpaquePointer(t)`
77	`}`

func cloneState.cloneSlice

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/clone.go:

func (state *cloneState) cloneSlice(v reflect.Value) reflect.Value {
        if v.IsNil() {
                return reflect.Zero(v.Type())
        }

        t := v.Type()
        num := v.Len()

        if state.visited != nil {
                vst := visit{
                        p:     v.Pointer(),
                        extra: num,
                        t:     t,
                }

                if val, ok := state.visited[vst]; ok {
                        return val
                }
        }

        c := v.Cap()
        nv := state.allocator.MakeSlice(t, num, c)

        if state.visited != nil {
                vst := visit{
                        p:     v.Pointer(),
                        extra: num,
                        t:     t,
                }
                state.visited[vst] = nv
        }

        // For scalar slice, copy underlying values directly.
        if state.allocator.isScalar(t.Elem().Kind()) {
                src := unsafe.Pointer(v.Pointer())
                dst := unsafe.Pointer(nv.Pointer())
                sz := int(t.Elem().Size())
                l := num * sz
                cc := c * sz
                copy((*[maxByteSize]byte)(dst)[:l:cc], (*[maxByteSize]byte)(src)[:l:cc])
        } else {
                for i := 0; i < num; i++ {
                        nv.Index(i).Set(state.clone(v.Index(i)))
                }
        }

        return nv
}

func cloneState.copyStruct

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/clone.go:

func (state *cloneState) copyStruct(src, nv reflect.Value) {
        t := src.Type()
        st := state.allocator.loadStructType(t)
        ptr := unsafe.Pointer(nv.Pointer())

        if st.Init(state.allocator, src, nv, state.skipCustomFuncValue == src) {
                return
        }

        for _, pf := range st.PointerFields {
                i := int(pf.Index)
                p := unsafe.Pointer(uintptr(ptr) + pf.Offset)
                field := src.Field(i)

                // This field can be referenced by a pointer or interface inside itself.
                // Put the pointer to this field to visited to avoid any error.
                //
                // See https://github.com/huandu/go-clone/issues/3.
                if state.visited != nil && field.CanAddr() {
                        ft := field.Type()
                        fp := field.Addr().Pointer()
                        vst := visit{
                                p: fp,
                                t: reflect.PtrTo(ft),
                        }
                        nv := reflect.NewAt(ft, p)

                        // The address of this field was visited, so fp must be a cycle pointer.
                        // As this field is not fully cloned, the val stored in visited[visit] must be wrong.
                        // It must be replaced by nv which will be the right value (it's incomplete right now).
                        //
                        // Unfortunately, if the val was used by previous clone routines,
                        // there is no easy way to fix wrong values - all pointers must be traversed and fixed.
                        if val, ok := state.visited[vst]; ok {
                                state.invalid[visit{
                                        p: val.Pointer(),
                                        t: vst.t,
                                }] = nv
                        }

                        state.visited[vst] = nv
                }

                v := state.clone(field)
                shadowCopy(v, p)
        }
}

func cloneState.cloneMap

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/clone.go:

func (state *cloneState) cloneMap(v reflect.Value) reflect.Value {
        if v.IsNil() {
                return reflect.Zero(v.Type())
        }

        t := v.Type()

        if state.visited != nil {
                vst := visit{
                        p: v.Pointer(),
                        t: t,
                }

                if val, ok := state.visited[vst]; ok {
                        return val
                }
        }

        nv := state.allocator.MakeMap(t, v.Len())

        if state.visited != nil {
                vst := visit{
                        p: v.Pointer(),
                        t: t,
                }
                state.visited[vst] = nv
        }

        for iter := mapIter(v); iter.Next(); {
                key := state.clone(iter.Key())
                value := state.clone(iter.Value())
                nv.SetMapIndex(key, value)
        }

        return nv
}

func init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/interfacedata.go:

func init() {
        t := reflect.TypeOf(reflect.Value{})
        found := false
        fields := t.NumField()

        for i := 0; i < fields; i++ {
                field := t.Field(i)

                if field.Type.Kind() == reflect.UnsafePointer {
                        found = true
                        reflectValuePtrOffset = field.Offset
                        break
                }
        }

        if !found {
                panic("go-clone: fail to find internal ptr field in reflect.Value")
        }
}

func Allocator.loadStructType

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/allocator.go:

func (a *Allocator) loadStructType(t reflect.Type) (st structType) {
        st, ok := a.lookupStructType(t)

        if ok {
                return
        }

        num := t.NumField()
        pointerFields := make([]structFieldType, 0, num)

        // Find pointer fields in depth-first order.
        for i := 0; i < num; i++ {
                field := t.Field(i)
                ft := field.Type
                k := ft.Kind()

                if a.isScalar(k) {
                        continue
                }

                switch k {
                case reflect.Array:
                        if ft.Len() == 0 {
                                continue
                        }

                        elem := ft.Elem()

                        if a.isScalar(elem.Kind()) {
                                continue
                        }

                        if elem.Kind() == reflect.Struct {
                                if fst := a.loadStructType(elem); fst.CanShadowCopy() {
                                        continue
                                }
                        }
                case reflect.Struct:
                        if fst := a.loadStructType(ft); fst.CanShadowCopy() {
                                continue
                        }
                }

                pointerFields = append(pointerFields, structFieldType{
                        Offset: field.Offset,
                        Index:  i,
                })
        }

        if len(pointerFields) == 0 {
                pointerFields = nil // Release memory ASAP.
        }

        st = structType{
                PointerFields: pointerFields,
        }

        // Load custom function.
        current := a

        for current != nil {
                if fn, ok := current.cachedCustomFuncTypes.Load(t); ok {
                        st.fn = fn.(Func)
                        break
                }

                current = current.parent
        }

        a.cachedStructTypes.LoadOrStore(t, st)
        return
}

func Allocator.isOpaquePointer

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/allocator.go:

func (a *Allocator) isOpaquePointer(t reflect.Type) (ok bool) {
        current := a

        for current != nil {
                if _, ok = current.cachedPointerTypes.Load(t); ok {
                        return
                }

                current = current.parent
        }

        return
}

func cloneSlowly

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/clone.go:

func cloneSlowly(allocator *Allocator, v interface{}) interface{} {
        if v == nil {
                return nil
        }

        val := reflect.ValueOf(v)
        cloned := allocator.cloneSlowly(val, false)
        return cloned.Interface()
}

func clone

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/clone.go:

func clone(allocator *Allocator, v interface{}) interface{} {
        if v == nil {
                return nil
        }

        val := reflect.ValueOf(v)
        cloned := allocator.clone(val, false)
        return cloned.Interface()
}

func cloneState.clone

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/clone.go:

func (state *cloneState) clone(v reflect.Value) reflect.Value {
        if state.allocator.isScalar(v.Kind()) {
                return copyScalarValue(v)
        }

        switch v.Kind() {
        case reflect.Array:
                return state.cloneArray(v)
        case reflect.Chan:
                return state.allocator.MakeChan(v.Type(), v.Cap())
        case reflect.Interface:
                return state.cloneInterface(v)
        case reflect.Map:
                return state.cloneMap(v)
        case reflect.Ptr:
                return state.clonePtr(v)
        case reflect.Slice:
                return state.cloneSlice(v)
        case reflect.Struct:
                return state.cloneStruct(v)
        case reflect.String:
                return state.cloneString(v)
        default:
                panic(fmt.Errorf("go-clone: <bug> unsupported type `%v`", v.Type()))
        }
}

func cloneState.copyArray

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/clone.go:

func (state *cloneState) copyArray(src, nv reflect.Value) {
        p := unsafe.Pointer(nv.Pointer()) // dst must be a Ptr.
        dst := nv.Elem()
        num := src.Len()

        if state.allocator.isScalar(src.Type().Elem().Kind()) {
                shadowCopy(src, p)
                return
        }

        for i := 0; i < num; i++ {
                dst.Index(i).Set(state.clone(src.Index(i)))
        }
}

func Allocator.cloneSlowly

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/allocator.go:

func (a *Allocator) cloneSlowly(val reflect.Value, inCustomFunc bool) reflect.Value {
        if !val.IsValid() {
                return val
        }

        state := &cloneState{
                allocator: a,
                visited:   visitMap{},
                invalid:   invalidPointers{},
        }

        if inCustomFunc {
                state.skipCustomFuncValue = val
        }

        cloned := state.clone(val)
        state.fix(cloned)
        return cloned
}

func Allocator.MarkAsScalar

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/allocator.go:

func (a *Allocator) MarkAsScalar(t reflect.Type) {
        t = utils.IndirectType(t)
        if t.Kind() != reflect.Struct {
                return
        }

        a.cachedStructTypes.Store(t, zeroStructType)
}

func cloneState.clonePtr

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/clone.go:

func (state *cloneState) clonePtr(v reflect.Value) reflect.Value {
        if v.IsNil() {
                return reflect.Zero(v.Type())
        }

        t := v.Type()

        if state.allocator.isOpaquePointer(t) {
                if v.CanInterface() {
                        return v
                }

                ptr := state.allocator.New(t)
                p := unsafe.Pointer(ptr.Pointer())
                shadowCopy(v, p)
                return ptr.Elem()
        }

        if state.visited != nil {
                vst := visit{
                        p: v.Pointer(),
                        t: t,
                }

                if val, ok := state.visited[vst]; ok {
                        return val
                }
        }

        src := v.Elem()
        elemType := src.Type()
        elemKind := src.Kind()
        nv := state.allocator.New(elemType)

        if state.visited != nil {
                vst := visit{
                        p: v.Pointer(),
                        t: t,
                }
                state.visited[vst] = nv
        }

        switch elemKind {
        case reflect.Struct:
                state.copyStruct(src, nv)
        case reflect.Array:
                state.copyArray(src, nv)
        default:
                nv.Elem().Set(state.clone(src))
        }

        // If this pointer is the address of a struct field and it's a cycle pointer,
        // it may be updated.
        if state.visited != nil {
                vst := visit{
                        p: v.Pointer(),
                        t: t,
                }
                nv = state.visited[vst]
        }

        return nv
}

func forceClearROFlag

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/structtype.go:

func forceClearROFlag(v reflect.Value) reflect.Value {
        var i interface{}
        indirect := 0

        // Save flagAddr.
        for v.CanAddr() {
                v = v.Addr()
                indirect++
        }

        v = v.Convert(typeOfInterface)
        nv := reflect.ValueOf(&i)
        *(*interfaceData)(unsafe.Pointer(nv.Pointer())) = parseReflectValue(v)
        cleared := nv.Elem().Elem()

        for indirect > 0 {
                cleared = cleared.Elem()
                indirect--
        }

        return cleared
}

func Allocator.clone

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/allocator.go:

func (a *Allocator) clone(val reflect.Value, inCustomFunc bool) reflect.Value {
        if !val.IsValid() {
                return val
        }

        state := &cloneState{
                allocator: a,
        }

        if inCustomFunc {
                state.skipCustomFuncValue = val
        }

        return state.clone(val)
}

func Allocator.SetCustomFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/allocator.go:

func (a *Allocator) SetCustomFunc(t reflect.Type, fn Func) {
        if fn == nil {
                a.cachedCustomFuncTypes.Delete(t)
                return
        }

        t = utils.IndirectType(t)
        if t.Kind() != reflect.Struct {
                return
        }

        a.cachedCustomFuncTypes.Store(t, fn)
}

func structType.Init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/structtype.go:

func (st *structType) Init(allocator *Allocator, src, nv reflect.Value, noCustomFunc bool) (done bool) {
        dst := nv.Elem()

        if !noCustomFunc && st.fn != nil {
                if !src.CanInterface() {
                        src = forceClearROFlag(src)
                }

                st.fn(allocator, src, dst)
                done = true
                return
        }

        ptr := unsafe.Pointer(nv.Pointer())
        shadowCopy(src, ptr)
        done = len(st.PointerFields) == 0
        return
}

func shadowCopy

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/clone.go:

func shadowCopy(src reflect.Value, p unsafe.Pointer) {
        switch src.Kind() {
        case reflect.Bool:
                *(*bool)(p) = src.Bool()
        case reflect.Int:
                *(*int)(p) = int(src.Int())
        case reflect.Int8:
                *(*int8)(p) = int8(src.Int())
        case reflect.Int16:
                *(*int16)(p) = int16(src.Int())
        case reflect.Int32:
                *(*int32)(p) = int32(src.Int())
        case reflect.Int64:
                *(*int64)(p) = src.Int()
        case reflect.Uint:
                *(*uint)(p) = uint(src.Uint())
        case reflect.Uint8:
                *(*uint8)(p) = uint8(src.Uint())
        case reflect.Uint16:
                *(*uint16)(p) = uint16(src.Uint())
        case reflect.Uint32:
                *(*uint32)(p) = uint32(src.Uint())
        case reflect.Uint64:
                *(*uint64)(p) = src.Uint()
        case reflect.Uintptr:
                *(*uintptr)(p) = uintptr(src.Uint())
        case reflect.Float32:
                *(*float32)(p) = float32(src.Float())
        case reflect.Float64:
                *(*float64)(p) = src.Float()
        case reflect.Complex64:
                *(*complex64)(p) = complex64(src.Complex())
        case reflect.Complex128:
                *(*complex128)(p) = src.Complex()

        case reflect.Array:
                t := src.Type()

                if src.CanAddr() {
                        srcPtr := unsafe.Pointer(src.UnsafeAddr())
                        sz := t.Size()
                        copy((*[maxByteSize]byte)(p)[:sz:sz], (*[maxByteSize]byte)(srcPtr)[:sz:sz])
                        return
                }

                val := reflect.NewAt(t, p).Elem()

                if src.CanInterface() {
                        val.Set(src)
                        return
                }

                sz := t.Elem().Size()
                num := src.Len()

                for i := 0; i < num; i++ {
                        elemPtr := unsafe.Pointer(uintptr(p) + uintptr(i)*sz)
                        shadowCopy(src.Index(i), elemPtr)
                }
        case reflect.Chan:
                *((*uintptr)(p)) = src.Pointer()
        case reflect.Func:
                t := src.Type()
                src = copyScalarValue(src)
                val := reflect.NewAt(t, p).Elem()
                val.Set(src)
        case reflect.Interface:
                *((*interfaceData)(p)) = parseReflectValue(src)
        case reflect.Map:
                *((*uintptr)(p)) = src.Pointer()
        case reflect.Ptr:
                *((*uintptr)(p)) = src.Pointer()
        case reflect.Slice:
                *(*sliceHeader)(p) = sliceHeader{
                        Data: src.Pointer(),
                        Len:  src.Len(),
                        Cap:  src.Cap(),
                }
        case reflect.String:
                s := src.String()
                val := reflect.NewAt(typeOfString, p).Elem()
                val.SetString(s)
        case reflect.Struct:
                t := src.Type()
                val := reflect.NewAt(t, p).Elem()

                if src.CanInterface() {
                        val.Set(src)
                        return
                }

                num := t.NumField()

                for i := 0; i < num; i++ {
                        field := t.Field(i)
                        fieldPtr := unsafe.Pointer(uintptr(p) + field.Offset)
                        shadowCopy(src.Field(i), fieldPtr)
                }
        case reflect.UnsafePointer:
                // There is no way to copy unsafe.Pointer value.
                *((*uintptr)(p)) = src.Pointer()

        default:
                panic(fmt.Errorf("go-clone: <bug> impossible type `%v` when cloning private field", src.Type()))
        }
}

func cloneState.fix

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/clone.go:

func (state *cloneState) fix(v reflect.Value) {
        if state == nil || len(state.invalid) == 0 {
                return
        }

        fix := &fixState{
                allocator: state.allocator,
                fixed:     fixMap{},
                invalid:   state.invalid,
        }
        fix.fix(v)
}

func copyScalarValue

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/structtype.go:

func copyScalarValue(src reflect.Value) reflect.Value {
        if src.CanInterface() {
                return src
        }

        // src is an unexported field value. Copy its value.
        switch src.Kind() {
        case reflect.Bool:
                return reflect.ValueOf(src.Bool())

        case reflect.Int:
                return reflect.ValueOf(int(src.Int()))
        case reflect.Int8:
                return reflect.ValueOf(int8(src.Int()))
        case reflect.Int16:
                return reflect.ValueOf(int16(src.Int()))
        case reflect.Int32:
                return reflect.ValueOf(int32(src.Int()))
        case reflect.Int64:
                return reflect.ValueOf(src.Int())

        case reflect.Uint:
                return reflect.ValueOf(uint(src.Uint()))
        case reflect.Uint8:
                return reflect.ValueOf(uint8(src.Uint()))
        case reflect.Uint16:
                return reflect.ValueOf(uint16(src.Uint()))
        case reflect.Uint32:
                return reflect.ValueOf(uint32(src.Uint()))
        case reflect.Uint64:
                return reflect.ValueOf(src.Uint())
        case reflect.Uintptr:
                return reflect.ValueOf(uintptr(src.Uint()))

        case reflect.Float32:
                return reflect.ValueOf(float32(src.Float()))
        case reflect.Float64:
                return reflect.ValueOf(src.Float())

        case reflect.Complex64:
                return reflect.ValueOf(complex64(src.Complex()))
        case reflect.Complex128:
                return reflect.ValueOf(src.Complex())

        case reflect.String:
                return reflect.ValueOf(src.String())
        case reflect.Func:
                t := src.Type()

                if src.IsNil() {
                        return reflect.Zero(t)
                }

                // Don't use this trick unless we have no choice.
                return forceClearROFlag(src)
        case reflect.UnsafePointer:
                return reflect.ValueOf(unsafe.Pointer(src.Pointer()))
        }

        panic(fmt.Errorf("go-clone: <bug> impossible type `%v` when cloning private field", src.Type()))
}

func fixState.fixMap

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/clone.go:

func (fix *fixState) fixMap(v reflect.Value) (copied reflect.Value, changed int) {
        if v.IsNil() {
                return
        }

        t := v.Type()
        vst := visit{
                p: v.Pointer(),
                t: t,
        }

        if _, ok := fix.fixed[vst]; ok {
                return
        }

        fix.fixed[vst] = struct{}{}

        kt := t.Key()
        et := t.Elem()
        keyKind := kt.Kind()
        elemKind := et.Kind()

        if isScalar := fix.allocator.isScalar; isScalar(keyKind) && isScalar(elemKind) {
                return
        }

        invalidKeys := map[reflect.Value][2]reflect.Value{}

        for iter := mapIter(v); iter.Next(); {
                key := iter.Key()
                elem := iter.Value()
                var fixed reflect.Value
                c := 0

                if elemKind == reflect.Ptr {
                        vst := visit{
                                p: elem.Pointer(),
                                t: et,
                        }

                        if nv, ok := fix.invalid[vst]; ok {
                                fixed = nv
                                c++
                        } else {
                                fixed, c = fix.fixPtr(elem)
                        }
                } else {
                        fixed, c = fix.fix(elem)
                }

                changed += c
                c = 0

                if fixed.IsValid() {
                        v = forceSetMapIndex(v, key, fixed)
                        elem = fixed
                        fixed = reflect.Value{}
                }

                if keyKind == reflect.Ptr {
                        vst := visit{
                                p: key.Pointer(),
                                t: kt,
                        }

                        if nv, ok := fix.invalid[vst]; ok {
                                fixed = nv
                                c++
                        } else {
                                fixed, c = fix.fixPtr(key)
                        }
                } else {
                        fixed, c = fix.fix(key)
                }

                changed += c

                // Key cannot be changed immediately inside map range iteration.
                // Do it later.
                if fixed.IsValid() {
                        invalidKeys[key] = [2]reflect.Value{fixed, elem}
                }
        }

        for key, kv := range invalidKeys {
                v = forceSetMapIndex(v, key, reflect.Value{})
                v = forceSetMapIndex(v, kv[0], kv[1])
        }

        return
}

func fixState.fixStruct

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/clone.go:

func (fix *fixState) fixStruct(v reflect.Value) (copied reflect.Value, changed int) {
        t := v.Type()
        st := fix.allocator.loadStructType(t)

        if len(st.PointerFields) == 0 {
                return
        }

        for _, pf := range st.PointerFields {
                i := int(pf.Index)
                field := v.Field(i)

                ft := field.Type()

                if ft.Kind() == reflect.Ptr {
                        vst := visit{
                                p: field.Pointer(),
                                t: ft,
                        }

                        if nv, ok := fix.invalid[vst]; ok {
                                // If v is not addressable, a new struct must be allocated.
                                // Don't do it unless there is no other choices.
                                if !v.CanAddr() {
                                        copied = fix.new(t).Elem()
                                        shadowCopy(v, unsafe.Pointer(copied.Addr().Pointer()))
                                        _, changed = fix.fixStruct(copied)
                                        return
                                }

                                ptr := unsafe.Pointer(v.Addr().Pointer())
                                p := unsafe.Pointer(uintptr(ptr) + pf.Offset)
                                shadowCopy(nv, p)
                                continue
                        }
                }

                fixed, c := fix.fix(field)
                changed += c

                if fixed.IsValid() {
                        // If v is not addressable, a new struct must be allocated.
                        // Don't do it unless there is no other choices.
                        if !v.CanAddr() {
                                copied = fix.new(t).Elem()
                                shadowCopy(v, unsafe.Pointer(copied.Addr().Pointer()))
                                _, changed = fix.fixStruct(copied)
                                return
                        }

                        ptr := unsafe.Pointer(v.Addr().Pointer())
                        p := unsafe.Pointer(uintptr(ptr) + pf.Offset)
                        shadowCopy(fixed, p)
                }
        }

        return
}

func fixState.fixArray

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/clone.go:

func (fix *fixState) fixArray(v reflect.Value) (copied reflect.Value, changed int) {
        t := v.Type()
        et := t.Elem()
        kind := et.Kind()

        if fix.allocator.isScalar(kind) {
                return
        }

        l := v.Len()

        for i := 0; i < l; i++ {
                elem := v.Index(i)

                if kind == reflect.Ptr {
                        vst := visit{
                                p: elem.Pointer(),
                                t: et,
                        }

                        if nv, ok := fix.invalid[vst]; ok {
                                // If elem cannot be set, v must be copied to make it settable.
                                // Don't do it unless there is no other choices.
                                if !elem.CanSet() {
                                        copied = fix.new(t).Elem()
                                        shadowCopy(v, unsafe.Pointer(copied.Addr().Pointer()))
                                        _, changed = fix.fixArray(copied)
                                        return
                                }

                                elem.Set(nv)
                                changed++
                                continue
                        }
                }

                fixed, c := fix.fix(elem)
                changed += c

                if fixed.IsValid() {
                        // If elem cannot be set, v must be copied to make it settable.
                        // Don't do it unless there is no other choices.
                        if !elem.CanSet() {
                                copied = fix.new(t).Elem()
                                shadowCopy(v, unsafe.Pointer(copied.Addr().Pointer()))
                                _, changed = fix.fixArray(copied)
                                return
                        }

                        elem.Set(fixed)
                }
        }

        return
}

func fixState.fixSlice

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/clone.go:

func (fix *fixState) fixSlice(v reflect.Value) (copied reflect.Value, changed int) {
        if v.IsNil() {
                return
        }

        t := v.Type()
        et := t.Elem()
        kind := et.Kind()

        if fix.allocator.isScalar(kind) {
                return
        }

        l := v.Len()
        p := unsafe.Pointer(v.Pointer())
        vst := visit{
                p:     uintptr(p),
                extra: l,
                t:     t,
        }

        if _, ok := fix.fixed[vst]; ok {
                return
        }

        fix.fixed[vst] = struct{}{}

        for i := 0; i < l; i++ {
                elem := v.Index(i)
                var fixed reflect.Value
                c := 0

                if kind == reflect.Ptr {
                        vst := visit{
                                p: elem.Pointer(),
                                t: et,
                        }

                        if nv, ok := fix.invalid[vst]; ok {
                                fixed = nv
                        } else {
                                fixed, c = fix.fixPtr(elem)
                        }
                } else {
                        fixed, c = fix.fix(elem)
                }

                changed += c

                if fixed.IsValid() {
                        sz := et.Size()
                        elemPtr := unsafe.Pointer(uintptr(p) + sz*uintptr(i))
                        shadowCopy(fixed, elemPtr)
                }
        }

        return
}

func wrap

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/wrapper.go:

func wrap(v interface{}) interface{} {
        if v == nil {
                return v
        }

        val := reflect.ValueOf(v)
        pt := val.Type()

        if val.Kind() != reflect.Ptr {
                return v
        }

        t := pt.Elem()
        elem := val.Elem()
        ptr := unsafe.Pointer(val.Pointer())
        cache, ok := cachedWrapperTypes.Load(t)

        if !ok {
                cache = reflect.StructOf([]reflect.StructField{
                        {
                                Name:      "T",
                                Type:      t,
                                Anonymous: true,
                        },
                        {
                                Name: "Checksum",
                                Type: reflect.TypeOf(uint64(0)),
                        },
                        {
                                Name: "Origin",
                                Type: pt,
                        },
                })
                cachedWrapperTypes.Store(t, cache)
        }

        wrapperType := cache.(reflect.Type)
        pw := defaultAllocator.New(wrapperType)

        wrapperPtr := unsafe.Pointer(pw.Pointer())
        wrapper := pw.Elem()

        // Equivalent code: wrapper.T = Clone(v)
        field := wrapper.Field(0)
        field.Set(heapCloneState.clone(elem))

        // Equivalent code: wrapper.Checksum = makeChecksum(v)
        checksumPtr := unsafe.Pointer(uintptr(wrapperPtr) + t.Size())
        *(*uint64)(checksumPtr) = makeChecksum(t, uintptr(wrapperPtr), uintptr(ptr))

        // Equivalent code: wrapper.Origin = v
        originPtr := unsafe.Pointer(uintptr(wrapperPtr) + t.Size() + sizeOfChecksum)
        *(*uintptr)(originPtr) = uintptr(ptr)

        return field.Addr().Interface()
}

func newAllocator

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/allocator.go:

func newAllocator(pool unsafe.Pointer, methods *AllocatorMethods) (allocator *Allocator) {
        parent := methods.parent()
        new := methods.new(parent, pool)

        // Allocate the allocator from the pool.
        val := new(pool, typeOfAllocator)
        allocator = (*Allocator)(unsafe.Pointer(val.Pointer()))
        runtime.KeepAlive(val)

        allocator.pool = pool
        allocator.new = new
        allocator.makeSlice = methods.makeSlice(parent, pool)
        allocator.makeMap = methods.makeMap(parent, pool)
        allocator.makeChan = methods.makeChan(parent, pool)
        allocator.isScalar = methods.isScalar(parent)

        if parent == nil {
                parent = defaultAllocator
        }

        allocator.parent = parent
        return
}

func fixState.fixInterface

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/clone.go:

func (fix *fixState) fixInterface(v reflect.Value) (copied reflect.Value, changed int) {
        if v.IsNil() {
                return
        }

        elem := v.Elem()
        t := elem.Type()
        kind := elem.Kind()

        if kind == reflect.Ptr {
                vst := visit{
                        p: elem.Pointer(),
                        t: t,
                }

                if nv, ok := fix.invalid[vst]; ok {
                        copied = nv.Convert(v.Type())
                        changed++
                        return
                }
        }

        copied, changed = fix.fix(elem)

        if copied.IsValid() {
                copied = copied.Convert(v.Type())
        }

        return
}

func fixState.fix

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/clone.go:

func (fix *fixState) fix(v reflect.Value) (copied reflect.Value, changed int) {
        if fix.allocator.isScalar(v.Kind()) {
                return
        }

        switch v.Kind() {
        case reflect.Array:
                return fix.fixArray(v)
        case reflect.Chan:
                // Do nothing.
                return
        case reflect.Interface:
                return fix.fixInterface(v)
        case reflect.Map:
                return fix.fixMap(v)
        case reflect.Ptr:
                return fix.fixPtr(v)
        case reflect.Slice:
                return fix.fixSlice(v)
        case reflect.Struct:
                return fix.fixStruct(v)
        case reflect.String:
                // Do nothing.
                return
        default:
                panic(fmt.Errorf("go-clone: <bug> unsupported type `%v`", v.Type()))
        }
}

func fixState.fixPtr

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/clone.go:

func (fix *fixState) fixPtr(v reflect.Value) (copied reflect.Value, changed int) {
        if v.IsNil() {
                return
        }

        vst := visit{
                p: v.Pointer(),
                t: v.Type(),
        }

        if _, ok := fix.invalid[vst]; ok {
                panic(fmt.Errorf("go-clone: <bug> invalid pointers must have been fixed in other methods"))
        }

        if _, ok := fix.fixed[vst]; ok {
                return
        }

        fix.fixed[vst] = struct{}{}

        elem := v.Elem()
        _, changed = fix.fix(elem)
        return
}

func cloneState.cloneString

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/clone.go:

func (state *cloneState) cloneString(v reflect.Value) reflect.Value {
        t := v.Type()
        l := v.Len()
        data := state.allocator.MakeSlice(typeOfByteSlice, l, l)

        // The v is an unexported struct field.
        if !v.CanInterface() {
                v = reflect.ValueOf(v.String())
        }

        reflect.Copy(data, v)

        nv := state.allocator.New(t)
        slice := data.Interface().([]byte)
        *(*stringHeader)(unsafe.Pointer(nv.Pointer())) = *(*stringHeader)(unsafe.Pointer(&slice))

        return nv.Elem()
}

func forceSetMapIndex

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/clone.go:

func forceSetMapIndex(v, key, elem reflect.Value) (nv reflect.Value) {
        nv = v

        if !v.CanInterface() {
                nv = forceClearROFlag(v)
        }

        if !key.CanInterface() {
                key = forceClearROFlag(key)
        }

        if elem.IsValid() && !elem.CanInterface() {
                elem = forceClearROFlag(elem)
        }

        nv.SetMapIndex(key, elem)
        return
}

func undo

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/wrapper.go:

func undo(v interface{}) {
        if v == nil {
                return
        }

        val := reflect.ValueOf(v)

        if !isWrapped(val) {
                return
        }

        origVal := origin(val)
        elem := val.Elem()
        elem.Set(heapCloneState.clone(origVal.Elem()))
}

func AllocatorMethods.makeChan

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/allocatormethods.go:

func (am *AllocatorMethods) makeChan(parent *Allocator, pool unsafe.Pointer) func(pool unsafe.Pointer, t reflect.Type, buffer int) reflect.Value {
        if am != nil && am.MakeChan != nil {
                return am.MakeChan
        }

        if parent != nil {
                if parent.pool == pool {
                        return parent.makeChan
                } else {
                        return func(pool unsafe.Pointer, t reflect.Type, buffer int) reflect.Value {
                                return parent.MakeChan(t, buffer)
                        }
                }
        }

        return defaultAllocator.makeChan
}

func @90:48

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/structtype.go:

func(allocator *Allocator, old, new reflect.Value) {
                if !old.CanAddr() {
                        return
                }

                // Clone value inside atomic.Value.
                oldValue := old.Addr().Interface().(*atomic.Value)
                newValue := new.Addr().Interface().(*atomic.Value)
                v := oldValue.Load()
                cloned := clone(allocator, v)
                newValue.Store(cloned)
        }

func AllocatorMethods.new

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/allocatormethods.go:

func (am *AllocatorMethods) new(parent *Allocator, pool unsafe.Pointer) func(pool unsafe.Pointer, t reflect.Type) reflect.Value {
        if am != nil && am.New != nil {
                return am.New
        }

        if parent != nil {
                if parent.pool == pool {
                        return parent.new
                } else {
                        return func(pool unsafe.Pointer, t reflect.Type) reflect.Value {
                                return parent.New(t)
                        }
                }
        }

        return defaultAllocator.new
}

func unwrap

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/wrapper.go:

func unwrap(v interface{}) interface{} {
        if v == nil {
                return v
        }

        val := reflect.ValueOf(v)

        if !isWrapped(val) {
                return v
        }

        origVal := origin(val)
        return origVal.Interface()
}

func AllocatorMethods.makeMap

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/allocatormethods.go:

func (am *AllocatorMethods) makeMap(parent *Allocator, pool unsafe.Pointer) func(pool unsafe.Pointer, t reflect.Type, n int) reflect.Value {
        if am != nil && am.MakeMap != nil {
                return am.MakeMap
        }

        if parent != nil {
                if parent.pool == pool {
                        return parent.makeMap
                } else {
                        return func(pool unsafe.Pointer, t reflect.Type, n int) reflect.Value {
                                return parent.MakeMap(t, n)
                        }
                }
        }

        return defaultAllocator.makeMap
}

func AllocatorMethods.makeSlice

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/allocatormethods.go:

func (am *AllocatorMethods) makeSlice(parent *Allocator, pool unsafe.Pointer) func(pool unsafe.Pointer, t reflect.Type, len, cap int) reflect.Value {
        if am != nil && am.MakeSlice != nil {
                return am.MakeSlice
        }

        if parent != nil {
                if parent.pool == pool {
                        return parent.makeSlice
                } else {
                        return func(pool unsafe.Pointer, t reflect.Type, len, cap int) reflect.Value {
                                return parent.MakeSlice(t, len, cap)
                        }
                }
        }

        return defaultAllocator.makeSlice
}

func isWrapped

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/wrapper.go:

func isWrapped(val reflect.Value) bool {
        pt := val.Type()

        if pt.Kind() != reflect.Ptr {
                return false
        }

        t := pt.Elem()
        ptr := unsafe.Pointer(val.Pointer())
        return validateChecksum(t, ptr)
}

func origin

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/wrapper.go:

func origin(val reflect.Value) reflect.Value {
        pt := val.Type()
        t := pt.Elem()
        ptr := unsafe.Pointer(val.Pointer())
        orig := getOrigin(t, ptr)
        origVal := reflect.NewAt(t, orig)
        return origVal
}

func Map

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/base.go:

func Map[T Clonable[T], K comparable](s map[K]T) (d map[K]T) {
        if s == nil {
                return
        }
        d = make(map[K]T, len(s))
        for k, v := range s {
                d[k] = v.Clone()
        }
        return
}

func Slice

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/base.go:

func Slice[T Clonable[T], TS ~[]T](s TS) (d TS) {
        if s == nil {
                return
        }
        d = make(TS, 0, len(s))
        for _, item := range s {
                d = append(d, item.Clone())
        }
        return
}

func @75:44

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/structtype.go:

func(allocator *Allocator, old, new reflect.Value) {
                if !old.CanAddr() {
                        return
                }

                // Clone all values inside sync.Map.
                oldMap := old.Addr().Interface().(*sync.Map)
                newMap := new.Addr().Interface().(*sync.Map)
                oldMap.Range(func(key, value interface{}) bool {
                        k := clone(allocator, key)
                        v := clone(allocator, value)
                        newMap.Store(k, v)
                        return true
                })
        }

func DecimalPtr

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/base.go:

func DecimalPtr(s *decimal.Decimal) (d *decimal.Decimal) {
        if s == nil {
                return
        }
        d = new(decimal.Decimal)
        *d = s.Copy()
        return
}

func ComparablePtr

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/base.go:

func ComparablePtr[T comparable](s *T) (d *T) {
        if s == nil {
                return
        }
        d = new(T)
        *d = *s
        return
}

func AllocatorMethods.isScalar

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/allocatormethods.go:

func (am *AllocatorMethods) isScalar(parent *Allocator) func(t reflect.Kind) bool {
        if am != nil && am.IsScalar != nil {
                return am.IsScalar
        }

        if parent != nil {
                return parent.isScalar
        }

        return defaultAllocator.isScalar
}

func validateChecksum

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/wrapper.go:

func validateChecksum(t reflect.Type, ptr unsafe.Pointer) bool {
        pw := uintptr(ptr)
        orig := uintptr(getOrigin(t, ptr))
        checksum := *(*uint64)(unsafe.Pointer(uintptr(ptr) + t.Size()))
        expected := makeChecksum(t, pw, orig)

        return checksum == expected
}

func SliceComparablePtr

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/base.go:

func SliceComparablePtr[T comparable, TS ~[]*T](s TS) (d TS) {
        if s == nil {
                return
        }
        d = make(TS, len(s), cap(s))
        copy(d, s)
        return
}

func TimePtr

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/base.go:

func TimePtr(s *time.Time) (d *time.Time) {
        if s == nil {
                return
        }
        d = new(time.Time)
        *d = time.Date(s.Year(), s.Month(), s.Day(), s.Hour(), s.Minute(), s.Second(), s.Nanosecond(),
                TimeLocationPtr(s.Location()))
        return
}

func makeChecksum

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/wrapper.go:

func makeChecksum(t reflect.Type, pw uintptr, orig uintptr) uint64 {
        var data [binary.MaxVarintLen64 * 2]byte
        binary.PutUvarint(data[:binary.MaxVarintLen64], uint64(pw))
        binary.PutUvarint(data[binary.MaxVarintLen64:], uint64(orig))
        return crc64.Checksum(data[:], crc64Table)
}

func TimeLocationPtr

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/base.go:

func TimeLocationPtr(s *time.Location) (d *time.Location) {
        if s == nil {
                return
        }
        d, _ = time.LoadLocation(s.String())
        return
}

func @83:16

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/structtype.go:

func(key, value interface{}) bool {
                        k := clone(allocator, key)
                        v := clone(allocator, value)
                        newMap.Store(k, v)
                        return true
                }

func AllocatorMethods.parent

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/allocatormethods.go:

func (am *AllocatorMethods) parent() *Allocator {
        if am != nil && am.Parent != nil {
                return am.Parent
        }

        return nil
}

func @69:45

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/structtype.go:

func(allocator *Allocator, old, new reflect.Value) {
                // Copy the New func from old value.
                oldFn := old.FieldByName("New")
                newFn := allocator.Clone(oldFn)
                new.FieldByName("New").Set(newFn)
        }

func @63:45

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/structtype.go:

func(allocator *Allocator, old, new reflect.Value) {
                // Copy the New func from old value.
                oldL := old.FieldByName("L")
                newL := allocator.Clone(oldL)
                new.FieldByName("L").Set(newL)
        }

func GormModelPtr

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/base.go:

func GormModelPtr(s *gorm.Model) (d *gorm.Model) {
        if s == nil {
                return
        }
        return &gorm.Model{
                ID:        s.ID,
                CreatedAt: *TimePtr(&s.CreatedAt),
                UpdatedAt: *TimePtr(&s.UpdatedAt),
                DeletedAt: gorm.DeletedAt{
                        Time:  *TimePtr(&s.DeletedAt.Time),
                        Valid: s.DeletedAt.Valid,
                },
        }
}

func fixState.new

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/clone.go:

473	`func (fix *fixState) new(t reflect.Type) reflect.Value {`
474	`return fix.allocator.New(t)`
475	`}`

func Undo

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/api_go118.go:

64	`func Undo[T any](t T) {`
65	`undo(t)`
66	`}`

func Unwrap

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/api_go118.go:

58	`func Unwrap[T any](t T) T {`
59	`return unwrap(t).(T)`
60	`}`

func heapMakeChan

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/allocator.go:

312	`func heapMakeChan(pool unsafe.Pointer, t reflect.Type, buffer int) reflect.Value {`
313	`return reflect.MakeChan(t, buffer)`
314	`}`

func Allocator.CloneSlowly

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/allocator.go:

121	`func (a *Allocator) CloneSlowly(val reflect.Value) reflect.Value {`
122	`return a.cloneSlowly(val, true)`
123	`}`

func Allocator.Clone

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/allocator.go:

99	`func (a *Allocator) Clone(val reflect.Value) reflect.Value {`
100	`return a.clone(val, true)`
101	`}`

func Allocator.MakeChan

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/allocator.go:

94	`func (a *Allocator) MakeChan(t reflect.Type, buffer int) reflect.Value {`
95	`return a.makeChan(a.pool, t, buffer)`
96	`}`

func NewAllocator

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/api_go118.go:

113	`func NewAllocator(pool unsafe.Pointer, methods AllocatorMethods) (allocator Allocator) {`
114	`return newAllocator(pool, methods)`
115	`}`

func @42:11

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/allocatormethods.go:

42	`func(pool unsafe.Pointer, t reflect.Type) reflect.Value {`
43	`return parent.New(t)`
44	`}`

func Wrap

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/api_go118.go:

52	`func Wrap[T any](t T) T {`
53	`return wrap(t).(T)`
54	`}`

func @60:11

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/allocatormethods.go:

60	`func(pool unsafe.Pointer, t reflect.Type, len, cap int) reflect.Value {`
61	`return parent.MakeSlice(t, len, cap)`
62	`}`

func @78:11

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/allocatormethods.go:

78	`func(pool unsafe.Pointer, t reflect.Type, n int) reflect.Value {`
79	`return parent.MakeMap(t, n)`
80	`}`

func getOrigin

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/wrapper.go:

108	`func getOrigin(t reflect.Type, ptr unsafe.Pointer) unsafe.Pointer {`
109	`return (unsafe.Pointer)(unsafe.Pointer(uintptr(ptr) + t.Size() + sizeOfChecksum))`
110	`}`

func @96:11

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/allocatormethods.go:

96	`func(pool unsafe.Pointer, t reflect.Type, buffer int) reflect.Value {`
97	`return parent.MakeChan(t, buffer)`
98	`}`

func FromHeap

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/api_go118.go:

102	`func FromHeap() *Allocator {`
103	`return fromHeap()`
104	`}`

func fromHeap

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/allocator.go:

43	`func fromHeap() *Allocator {`
44	`return newAllocator(nil, nil)`
45	`}`

func emptyCloneFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/clone/structtype.go:

138	`func emptyCloneFunc(allocator *Allocator, old, new reflect.Value) {}`

Package Overview: github.com/wfusion/gofusion/common/utils/cmp 23.1%

Please select a function to see what's left for testing.

`MapAny(...)`	`github.com/wfusion/gofusion/common/utils/cmp/base.go`	`77.8%`	`7/9`
`SliceComparable(...)`	`github.com/wfusion/gofusion/common/utils/cmp/base.go`	`62.5%`	`5/8`
`ComparablePtr(...)`	`github.com/wfusion/gofusion/common/utils/cmp/base.go`	`60.0%`	`3/5`
`SliceAny(...)`	`github.com/wfusion/gofusion/common/utils/cmp/base.go`	`54.5%`	`6/11`
`anything(...)`	`github.com/wfusion/gofusion/common/utils/cmp/base.go`	`22.5%`	`9/40`
`deref(...)`	`github.com/wfusion/gofusion/common/utils/cmp/base.go`	`13.6%`	`3/22`
`Slice(...)`	`github.com/wfusion/gofusion/common/utils/cmp/base.go`	`0.0%`	`0/11`
`Map(...)`	`github.com/wfusion/gofusion/common/utils/cmp/base.go`	`0.0%`	`0/9`
`SliceComparablePtr(...)`	`github.com/wfusion/gofusion/common/utils/cmp/base.go`	`0.0%`	`0/8`
`DecimalPtr(...)`	`github.com/wfusion/gofusion/common/utils/cmp/base.go`	`0.0%`	`0/5`
`TimeLocationPtr(...)`	`github.com/wfusion/gofusion/common/utils/cmp/base.go`	`0.0%`	`0/5`
`TimePtr(...)`	`github.com/wfusion/gofusion/common/utils/cmp/base.go`	`0.0%`	`0/5`
`GormModelPtr(...)`	`github.com/wfusion/gofusion/common/utils/cmp/base.go`	`0.0%`	`0/5`

func MapAny

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cmp/base.go:

func MapAny[K comparable, T any](a, b map[K]T) bool {
        if a == nil && b == nil {
                return true
        }
        if a == nil || b == nil || len(a) != len(b) {
                return false
        }

        for ak, av := range a {
                bv, ok := b[ak]
                if !ok || !anything(av, bv) {
                        return false
                }

        }
        return true
}

func SliceComparable

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cmp/base.go:

func SliceComparable[T comparable, TS ~[]T](a, b TS) bool {
        if a == nil && b == nil {
                return true
        }
        if a == nil || b == nil || len(a) != len(b) {
                return false
        }
        for i := 0; i < len(a); i++ {
                if a[i] != b[i] {
                        return false
                }
        }
        return true
}

func ComparablePtr

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cmp/base.go:

func ComparablePtr[T comparable](a, b *T) bool {
        if a == nil && b == nil {
                return true
        }
        if a == nil || b == nil {
                return false
        }

        return *a == *b
}

func SliceAny

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cmp/base.go:

func SliceAny[T any, TS ~[]T](a, b TS, sortFn func(i, j T) int) bool {
        if a == nil && b == nil {
                return true
        }
        if a == nil || b == nil || len(a) != len(b) {
                return false
        }

        if sortFn != nil {
                utils.SortStable(a, sortFn)
                utils.SortStable(b, sortFn)
        }

        for i := 0; i < len(a); i++ {
                if !anything(a[i], b[i]) {
                        return false
                }
        }
        return true
}

func anything

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cmp/base.go:

func anything(a, b any) bool {
        switch av := a.(type) {
        case
                        bool,
                        string, uintptr,
                        int, int8, int16, int32, int64,
                        uint, uint8, uint16, uint32, uint64,
                        float32, float64,
                        complex64, complex128:
                return a == b
        case
                        *bool,
                        *string, *uintptr,
                        *int, *int8, *int16, *int32, *int64,
                        *uint, *uint8, *uint16, *uint32, *uint64,
                        *float32, *float64,
                        *complex64, *complex128:
                if a == nil && b == nil {
                        return true
                }
                if a == nil || b == nil {
                        return false
                }
                return anything(deref(a), deref(b))
        case decimal.Decimal:
                bv := b.(decimal.Decimal)
                return DecimalPtr(&av, &bv)
        case *decimal.Decimal:
                bv := b.(*decimal.Decimal)
                return DecimalPtr(av, bv)
        case time.Time:
                bv := b.(time.Time)
                return TimePtr(&av, &bv)
        case *time.Time:
                bv := b.(*time.Time)
                return TimePtr(av, bv)
        case time.Location:
                bv := b.(time.Location)
                return TimeLocationPtr(&av, &bv)
        case *time.Location:
                bv := b.(*time.Location)
                return TimeLocationPtr(av, bv)
        case []bool:
                return SliceComparable(a.([]bool), b.([]bool))
        case []string:
                return SliceComparable(a.([]string), b.([]string))
        case []uintptr:
                return SliceComparable(a.([]uintptr), b.([]uintptr))
        case []int:
                return SliceComparable(a.([]int), b.([]int))
        case []int8:
                return SliceComparable(a.([]int8), b.([]int8))
        case []int16:
                return SliceComparable(a.([]int16), b.([]int16))
        case []int32:
                return SliceComparable(a.([]int32), b.([]int32))
        case []int64:
                return SliceComparable(a.([]int64), b.([]int64))
        case []uint:
                return SliceComparable(a.([]uint), b.([]uint))
        case []uint8:
                return SliceComparable(a.([]uint8), b.([]uint8))
        case []uint16:
                return SliceComparable(a.([]uint16), b.([]uint16))
        case []uint32:
                return SliceComparable(a.([]uint32), b.([]uint32))
        case []uint64:
                return SliceComparable(a.([]uint64), b.([]uint64))
        case []float32:
                return SliceComparable(a.([]float32), b.([]float32))
        case []float64:
                return SliceComparable(a.([]float64), b.([]float64))
        case []complex64:
                return SliceComparable(a.([]complex64), b.([]complex64))
        case []complex128:
                return SliceComparable(a.([]complex128), b.([]complex128))
        case []any:
                return SliceAny(a.([]any), b.([]any), nil)
        case []map[string]any:
                return SliceAny(a.([]map[string]any), b.([]map[string]any), nil)
        case map[string]any:
                return MapAny(av, b.(map[string]any))
        default:
                return reflect.DeepEqual(a, b)
        }
}

func deref

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cmp/base.go:

func deref(p any) (v any) {
        switch pp := p.(type) {
        case *bool:
                v = *pp
        case *string:
                v = *pp
        case *int:
                v = *pp
        case *int8:
                v = *pp
        case *int16:
                v = *pp
        case *int32:
                v = *pp
        case *int64:
                v = *pp
        case *uint:
                v = *pp
        case *uint8:
                v = *pp
        case *uint16:
                v = *pp
        case *uint32:
                v = *pp
        case *uint64:
                v = *pp
        case *float32:
                v = *pp
        case *float64:
                v = *pp
        case *complex64:
                v = *pp
        case *complex128:
                v = *pp
        case *uintptr:
                v = *pp
        case *[]byte:
                v = *pp
        case *any:
                v = *pp
        default:
                panic(fmt.Errorf("unsupported type %T", pp))
        }
        return
}

func Slice

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cmp/base.go:

func Slice[T _comparable[T], TS ~[]T](a, b TS, sortFn func(i, j T) int) bool {
        if a == nil && b == nil {
                return true
        }
        if a == nil || b == nil || len(a) != len(b) {
                return false
        }

        if sortFn != nil {
                utils.SortStable(a, sortFn)
                utils.SortStable(b, sortFn)
        }

        for i := 0; i < len(a); i++ {
                if !a[i].Equals(b[i]) {
                        return false
                }
        }
        return true
}

func Map

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cmp/base.go:

func Map[T _comparable[T], K comparable](a, b map[K]T) bool {
        if a == nil && b == nil {
                return true
        }
        if a == nil || b == nil || len(a) != len(b) {
                return false
        }

        for ak, av := range a {
                bv, ok := b[ak]
                if !ok || !av.Equals(bv) {
                        return false
                }
        }

        return true
}

func SliceComparablePtr

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cmp/base.go:

func SliceComparablePtr[T comparable, TS ~[]*T](a, b TS) bool {
        if a == nil && b == nil {
                return true
        }
        if a == nil || b == nil || len(a) != len(b) {
                return false
        }
        for i := 0; i < len(a); i++ {
                if deref(a[i]) != deref(b[i]) {
                        return false
                }
        }
        return true
}

func DecimalPtr

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cmp/base.go:

func DecimalPtr(a, b *decimal.Decimal) bool {
        if a == nil && b == nil {
                return true
        }
        if a == nil || b == nil {
                return false
        }

        return a.Equal(*b)
}

func TimeLocationPtr

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cmp/base.go:

func TimeLocationPtr(a, b *time.Location) bool {
        if a == nil && b == nil {
                return true
        }
        if a == nil || b == nil {
                return false
        }

        return a.String() == b.String()
}

func TimePtr

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cmp/base.go:

func TimePtr(a, b *time.Time) bool {
        if a == nil && b == nil {
                return true
        }
        if a == nil || b == nil {
                return false
        }

        return a.Equal(*b) && TimeLocationPtr(a.Location(), b.Location())
}

func GormModelPtr

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/cmp/base.go:

func GormModelPtr(a, b *gorm.Model) bool {
        if a == nil && b == nil {
                return true
        }
        if a == nil || b == nil {
                return false
        }

        return a.ID == b.ID &&
                TimePtr(&a.CreatedAt, &b.CreatedAt) &&
                TimePtr(&a.UpdatedAt, &b.UpdatedAt) &&
                a.DeletedAt.Valid == b.DeletedAt.Valid &&
                TimePtr(&a.DeletedAt.Time, &b.DeletedAt.Time)
}

Package Overview: github.com/wfusion/gofusion/common/utils/compress 73.7%

Please select a function to see what's left for testing.

`@20:9(...)`	`github.com/wfusion/gofusion/common/utils/compress/decode.go`	`100.0%`	`3/3`
`@31:24(...)`	`github.com/wfusion/gofusion/common/utils/compress/decode.go`	`100.0%`	`3/3`
`@32:24(...)`	`github.com/wfusion/gofusion/common/utils/compress/encode.go`	`100.0%`	`3/3`
`@21:9(...)`	`github.com/wfusion/gofusion/common/utils/compress/encode.go`	`100.0%`	`3/3`
`decoder.Close(...)`	`github.com/wfusion/gofusion/common/utils/compress/decode.go`	`100.0%`	`3/3`
`encoder.Close(...)`	`github.com/wfusion/gofusion/common/utils/compress/encode.go`	`100.0%`	`3/3`
`@92:9(...)`	`github.com/wfusion/gofusion/common/utils/compress/decode.go`	`100.0%`	`2/2`
`deflateDecodable.Reset(...)`	`github.com/wfusion/gofusion/common/utils/compress/wrapper.go`	`100.0%`	`2/2`
`gzipDecodable.Reset(...)`	`github.com/wfusion/gofusion/common/utils/compress/wrapper.go`	`100.0%`	`2/2`
`s2Decodable.Reset(...)`	`github.com/wfusion/gofusion/common/utils/compress/wrapper.go`	`100.0%`	`2/2`
`encoder.Flush(...)`	`github.com/wfusion/gofusion/common/utils/compress/encode.go`	`100.0%`	`2/2`
`zlibDecodable.Reset(...)`	`github.com/wfusion/gofusion/common/utils/compress/wrapper.go`	`100.0%`	`2/2`
`@33:32(...)`	`github.com/wfusion/gofusion/common/utils/compress/types.go`	`100.0%`	`1/1`
`NewDecFunc(...)`	`github.com/wfusion/gofusion/common/utils/compress/decode.go`	`100.0%`	`1/1`
`zlibDecodable.Read(...)`	`github.com/wfusion/gofusion/common/utils/compress/wrapper.go`	`100.0%`	`1/1`
`Algorithm.String(...)`	`github.com/wfusion/gofusion/common/utils/compress/algorithm_enum.go`	`100.0%`	`1/1`
`decoder.Read(...)`	`github.com/wfusion/gofusion/common/utils/compress/decode.go`	`100.0%`	`1/1`
`deflateDecodable.Read(...)`	`github.com/wfusion/gofusion/common/utils/compress/wrapper.go`	`100.0%`	`1/1`
`EncodeBytesFunc(...)`	`github.com/wfusion/gofusion/common/utils/compress/encode.go`	`100.0%`	`1/1`
`Algorithm.IsValid(...)`	`github.com/wfusion/gofusion/common/utils/compress/algorithm_enum.go`	`100.0%`	`1/1`
`gzipDecodable.Read(...)`	`github.com/wfusion/gofusion/common/utils/compress/wrapper.go`	`100.0%`	`1/1`
`s2Decodable.Read(...)`	`github.com/wfusion/gofusion/common/utils/compress/wrapper.go`	`100.0%`	`1/1`
`writerPoolSealer.Reset(...)`	`github.com/wfusion/gofusion/common/utils/compress/types.go`	`100.0%`	`1/1`
`readerPoolSealer.Reset(...)`	`github.com/wfusion/gofusion/common/utils/compress/types.go`	`100.0%`	`1/1`
`@54:35(...)`	`github.com/wfusion/gofusion/common/utils/compress/types.go`	`100.0%`	`1/1`
`@51:32(...)`	`github.com/wfusion/gofusion/common/utils/compress/types.go`	`100.0%`	`1/1`
`@48:30(...)`	`github.com/wfusion/gofusion/common/utils/compress/types.go`	`100.0%`	`1/1`
`NewEncFunc(...)`	`github.com/wfusion/gofusion/common/utils/compress/encode.go`	`100.0%`	`1/1`
`@45:32(...)`	`github.com/wfusion/gofusion/common/utils/compress/types.go`	`100.0%`	`1/1`
`encoder.Write(...)`	`github.com/wfusion/gofusion/common/utils/compress/encode.go`	`100.0%`	`1/1`
`@42:32(...)`	`github.com/wfusion/gofusion/common/utils/compress/types.go`	`100.0%`	`1/1`
`DecodeBytesFunc(...)`	`github.com/wfusion/gofusion/common/utils/compress/decode.go`	`100.0%`	`1/1`
`@36:35(...)`	`github.com/wfusion/gofusion/common/utils/compress/types.go`	`100.0%`	`1/1`
`@24:32(...)`	`github.com/wfusion/gofusion/common/utils/compress/types.go`	`100.0%`	`1/1`
`@27:32(...)`	`github.com/wfusion/gofusion/common/utils/compress/types.go`	`100.0%`	`1/1`
`@30:30(...)`	`github.com/wfusion/gofusion/common/utils/compress/types.go`	`100.0%`	`1/1`
`Algorithm.Value(...)`	`github.com/wfusion/gofusion/common/utils/compress/algorithm_enum.go`	`100.0%`	`1/1`
`@15:9(...)`	`github.com/wfusion/gofusion/common/utils/compress/decode.go`	`87.5%`	`14/16`
`ParseAlgorithm(...)`	`github.com/wfusion/gofusion/common/utils/compress/algorithm_enum.go`	`83.3%`	`5/6`
`getDecoder(...)`	`github.com/wfusion/gofusion/common/utils/compress/decode.go`	`83.3%`	`5/6`
`getEncoder(...)`	`github.com/wfusion/gofusion/common/utils/compress/encode.go`	`83.3%`	`5/6`
`@103:9(...)`	`github.com/wfusion/gofusion/common/utils/compress/encode.go`	`75.0%`	`3/4`
`@16:9(...)`	`github.com/wfusion/gofusion/common/utils/compress/encode.go`	`73.7%`	`14/19`
`@61:9(...)`	`github.com/wfusion/gofusion/common/utils/compress/encode.go`	`0.0%`	`0/9`
`@54:9(...)`	`github.com/wfusion/gofusion/common/utils/compress/decode.go`	`0.0%`	`0/6`
`@69:9(...)`	`github.com/wfusion/gofusion/common/utils/compress/encode.go`	`0.0%`	`0/2`
`@59:9(...)`	`github.com/wfusion/gofusion/common/utils/compress/decode.go`	`0.0%`	`0/2`
`EncodeStreamFunc(...)`	`github.com/wfusion/gofusion/common/utils/compress/encode.go`	`0.0%`	`0/1`
`@66:27(...)`	`github.com/wfusion/gofusion/common/utils/compress/encode.go`	`0.0%`	`0/1`
`encoder.Reset(...)`	`github.com/wfusion/gofusion/common/utils/compress/encode.go`	`0.0%`	`0/1`
`decoder.Reset(...)`	`github.com/wfusion/gofusion/common/utils/compress/decode.go`	`0.0%`	`0/1`
`@65:27(...)`	`github.com/wfusion/gofusion/common/utils/compress/decode.go`	`0.0%`	`0/1`
`DecodeStreamFunc(...)`	`github.com/wfusion/gofusion/common/utils/compress/decode.go`	`0.0%`	`0/1`

func @20:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/decode.go:

20	`func() {`
21	`for _, cb := range recycles {`
22	`if cb != nil {`
23	`cb()`
24	`}`
25	`}`
26	`}`

func @31:24

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/decode.go:

func() {
                        var cb func()
                        dec, cb = getDecoder(algo, srcBuffer)
                        recycles = append(recycles, cb)
                }

func @32:24

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/encode.go:

func() {
                        var cb func()
                        enc, cb = getEncoder(algo, dstBuffer)
                        recycles = append(recycles, cb)
                }

func @21:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/encode.go:

21	`func() {`
22	`for _, cb := range recycles {`
23	`if cb != nil {`
24	`cb()`
25	`}`
26	`}`
27	`}`

func decoder.Close

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/decode.go:

104	`func (e *decoder) Close() (err error) { defer e.cb(); utils.CloseAnyway(e.r); return }`

func encoder.Close

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/encode.go:

func (e *encoder) Close() (err error) {
        defer e.cb()
        defer utils.CloseAnyway(e.w)
        return e.Flush()
}

func @92:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/decode.go:

func(r io.Reader) io.ReadCloser {
                dec, cb := getDecoder(algo, r)
                return &decoder{
                        dec: dec,
                        r:   r,
                        cb:  cb,
                }
        }

func deflateDecodable.Reset

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/wrapper.go:

31	`func (d *deflateDecodable) Reset(r io.Reader) (err error) { d.ReadCloser = flate.NewReader(r); return }`

func gzipDecodable.Reset

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/wrapper.go:

24	`func (g *gzipDecodable) Reset(r io.Reader) (err error) { g.ReadCloser, err = gzip.NewReader(r); return }`

func s2Decodable.Reset

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/wrapper.go:

17	`func (s *s2Decodable) Reset(r io.Reader) (err error) { s.Reader.Reset(r); return }`

func encoder.Flush

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/encode.go:

118	`func (e *encoder) Flush() (err error) { defer utils.FlushAnyway(e.w); return e.enc.Flush() }`

func zlibDecodable.Reset

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/wrapper.go:

38	`func (z *zlibDecodable) Reset(r io.Reader) (err error) { z.ReadCloser, err = zlib.NewReader(r); return }`

func @33:32

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/types.go:

33	`func() *writerPoolSealer {`
34	`return &writerPoolSealer{gzip.NewWriter(nil)}`
35	`}`

func NewDecFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/decode.go:

func NewDecFunc(algo Algorithm) func(r io.Reader) io.ReadCloser {
        return func(r io.Reader) io.ReadCloser {
                dec, cb := getDecoder(algo, r)
                return &decoder{
                        dec: dec,
                        r:   r,
                        cb:  cb,
                }
        }
}

func zlibDecodable.Read

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/wrapper.go:

37	`func (z *zlibDecodable) Read(p []byte) (n int, err error) { return z.ReadCloser.Read(p) }`

func Algorithm.String

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/algorithm_enum.go:

37	`func (e Algorithm) String() string {`
38	`return algorithmEnum.String(e)`
39	`}`

func decoder.Read

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/decode.go:

103	`func (e *decoder) Read(p []byte) (n int, err error) { return e.dec.Read(p) }`

func deflateDecodable.Read

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/wrapper.go:

30	`func (d *deflateDecodable) Read(p []byte) (n int, err error) { return d.ReadCloser.Read(p) }`

func EncodeBytesFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/encode.go:

func EncodeBytesFunc(algo Algorithm) func(src []byte) (dst []byte, err error) {
        return func(src []byte) (dst []byte, err error) {
                var (
                        enc      encodable
                        recycles []func()
                )
                defer func() {
                        for _, cb := range recycles {
                                if cb != nil {
                                        cb()
                                }
                        }
                }()

                dstBuffer, bufferCb := utils.BytesBufferPool.Get(nil)
                recycles = append(recycles, bufferCb)

                _, err = utils.Catch(func() {
                        var cb func()
                        enc, cb = getEncoder(algo, dstBuffer)
                        recycles = append(recycles, cb)
                })
                if err != nil || enc == nil {
                        return
                }

                srcBuffer, bufferCb := utils.BytesBufferPool.Get(nil)
                recycles = append(recycles, bufferCb)
                srcBuffer.Write(src)
                if _, err = io.Copy(enc, srcBuffer); err != nil {
                        if err = utils.ErrIgnore(err, eofErrs...); err != nil {
                                return
                        }
                }
                if err = enc.Flush(); err != nil {
                        if err = utils.ErrIgnore(err, eofErrs...); err != nil {
                                return
                        }
                }
                dst = make([]byte, dstBuffer.Len())
                copy(dst, dstBuffer.Bytes())
                return
        }
}

func Algorithm.IsValid

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/algorithm_enum.go:

41	`func (e Algorithm) IsValid() bool {`
42	`return algorithmEnum.IsValid(e)`
43	`}`

func gzipDecodable.Read

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/wrapper.go:

23	`func (g *gzipDecodable) Read(p []byte) (n int, err error) { return g.ReadCloser.Read(p) }`

func s2Decodable.Read

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/wrapper.go:

16	`func (s *s2Decodable) Read(p []byte) (n int, err error) { return s.Reader.Read(p) }`

func writerPoolSealer.Reset

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/types.go:

70	`func (w *writerPoolSealer) Reset(obj any) {`
71	`w.encodable.Reset(obj.(io.Writer))`
72	`}`

func readerPoolSealer.Reset

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/types.go:

64	`func (r *readerPoolSealer) Reset(obj any) error {`
65	`return r.decodable.Reset(obj.(io.Reader))`
66	`}`

func @54:35

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/types.go:

54	`func() *readerPoolSealer {`
55	`return &readerPoolSealer{new(deflateDecodable)} // init when call reset method`
56	`}`

func @51:32

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/types.go:

51	`func() *readerPoolSealer {`
52	`return &readerPoolSealer{new(gzipDecodable)} // init when call reset method`
53	`}`

func @48:30

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/types.go:

48	`func() *readerPoolSealer {`
49	`return &readerPoolSealer{&s2Decodable{s2.NewReader(nil)}}`
50	`}`

func NewEncFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/encode.go:

func NewEncFunc(algo Algorithm) func(w io.Writer) encodable {
        return func(w io.Writer) encodable {
                enc, cb := getEncoder(algo, w)
                if enc == nil {
                        panic(ErrUnknownAlgorithm)
                }
                return &encoder{
                        enc: enc,
                        w:   w,
                        cb:  cb,
                }
        }
}

func @45:32

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/types.go:

45	`func() *readerPoolSealer {`
46	`return &readerPoolSealer{new(zlibDecodable)} // init when call reset method`
47	`}`

func encoder.Write

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/encode.go:

116	`func (e *encoder) Write(p []byte) (n int, err error) { return e.enc.Write(p) }`

func @42:32

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/types.go:

42	`func() *readerPoolSealer {`
43	`return &readerPoolSealer{utils.Must(zstd.NewReader(nil))}`
44	`}`

func DecodeBytesFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/decode.go:

func DecodeBytesFunc(algo Algorithm) func(src []byte) (dst []byte, err error) {
        return func(src []byte) (dst []byte, err error) {
                var (
                        dec      decodable
                        recycles []func()
                )
                defer func() {
                        for _, cb := range recycles {
                                if cb != nil {
                                        cb()
                                }
                        }
                }()

                srcBuffer, bufferCb := utils.BytesBufferPool.Get(nil)
                recycles = append(recycles, bufferCb)
                srcBuffer.Write(src)
                _, err = utils.Catch(func() {
                        var cb func()
                        dec, cb = getDecoder(algo, srcBuffer)
                        recycles = append(recycles, cb)
                })
                if err != nil || dec == nil {
                        return
                }

                dstBuffer, bufferCb := utils.BytesBufferPool.Get(nil)
                recycles = append(recycles, bufferCb)
                if _, err = io.Copy(dstBuffer, dec); err != nil {
                        if err = utils.ErrIgnore(err, eofErrs...); err != nil {
                                return
                        }
                }
                dst = make([]byte, dstBuffer.Len())
                copy(dst, dstBuffer.Bytes())
                return
        }
}

func @36:35

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/types.go:

36	`func() *writerPoolSealer {`
37	`return &writerPoolSealer{utils.Must(flate.NewWriter(nil, flate.DefaultCompression))}`
38	`}`

func @24:32

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/types.go:

24	`func() *writerPoolSealer {`
25	`return &writerPoolSealer{utils.Must(zstd.NewWriter(nil))}`
26	`}`

func @27:32

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/types.go:

27	`func() *writerPoolSealer {`
28	`return &writerPoolSealer{zlib.NewWriter(nil)}`
29	`}`

func @30:30

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/types.go:

30	`func() *writerPoolSealer {`
31	`return &writerPoolSealer{s2.NewWriter(nil)}`
32	`}`

func Algorithm.Value

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/algorithm_enum.go:

33	`func (e Algorithm) Value() uint8 {`
34	`return uint8(e)`
35	`}`

func @15:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/decode.go:

func(src []byte) (dst []byte, err error) {
                var (
                        dec      decodable
                        recycles []func()
                )
                defer func() {
                        for _, cb := range recycles {
                                if cb != nil {
                                        cb()
                                }
                        }
                }()

                srcBuffer, bufferCb := utils.BytesBufferPool.Get(nil)
                recycles = append(recycles, bufferCb)
                srcBuffer.Write(src)
                _, err = utils.Catch(func() {
                        var cb func()
                        dec, cb = getDecoder(algo, srcBuffer)
                        recycles = append(recycles, cb)
                })
                if err != nil || dec == nil {
                        return
                }

                dstBuffer, bufferCb := utils.BytesBufferPool.Get(nil)
                recycles = append(recycles, bufferCb)
                if _, err = io.Copy(dstBuffer, dec); err != nil {
                        if err = utils.ErrIgnore(err, eofErrs...); err != nil {
                                return
                        }
                }
                dst = make([]byte, dstBuffer.Len())
                copy(dst, dstBuffer.Bytes())
                return
        }

func ParseAlgorithm

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/algorithm_enum.go:

func ParseAlgorithm(s any) Algorithm {
        switch v := s.(type) {
        case string:
                if enumList := algorithmEnum.Enum(v); len(enumList) > 0 {
                        return enumList[0]
                }
        case Algorithm:
                return v
        default:
                return Algorithm(cast.ToInt(s))
        }
        return AlgorithmUnknown
}

func getDecoder

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/decode.go:

func getDecoder(algo Algorithm, src io.Reader) (dec decodable, recycle func()) {
        p, ok := decoderPools[algo]
        if !algo.IsValid() || !ok {
                panic(ErrUnknownAlgorithm)
        }

        sealer, recycle := p.Get(src)
        dec = sealer.decodable
        return
}

func getEncoder

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/encode.go:

func getEncoder(algo Algorithm, dst io.Writer) (enc encodable, recycle func()) {
        p, ok := encoderPools[algo]
        if !algo.IsValid() || !ok {
                panic(ErrUnknownAlgorithm)
        }

        sealer, recycle := p.Get(dst)
        enc = sealer.encodable
        return
}

func @103:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/encode.go:

func(w io.Writer) encodable {
                enc, cb := getEncoder(algo, w)
                if enc == nil {
                        panic(ErrUnknownAlgorithm)
                }
                return &encoder{
                        enc: enc,
                        w:   w,
                        cb:  cb,
                }
        }

func @16:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/encode.go:

func(src []byte) (dst []byte, err error) {
                var (
                        enc      encodable
                        recycles []func()
                )
                defer func() {
                        for _, cb := range recycles {
                                if cb != nil {
                                        cb()
                                }
                        }
                }()

                dstBuffer, bufferCb := utils.BytesBufferPool.Get(nil)
                recycles = append(recycles, bufferCb)

                _, err = utils.Catch(func() {
                        var cb func()
                        enc, cb = getEncoder(algo, dstBuffer)
                        recycles = append(recycles, cb)
                })
                if err != nil || enc == nil {
                        return
                }

                srcBuffer, bufferCb := utils.BytesBufferPool.Get(nil)
                recycles = append(recycles, bufferCb)
                srcBuffer.Write(src)
                if _, err = io.Copy(enc, srcBuffer); err != nil {
                        if err = utils.ErrIgnore(err, eofErrs...); err != nil {
                                return
                        }
                }
                if err = enc.Flush(); err != nil {
                        if err = utils.ErrIgnore(err, eofErrs...); err != nil {
                                return
                        }
                }
                dst = make([]byte, dstBuffer.Len())
                copy(dst, dstBuffer.Bytes())
                return
        }

func @61:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/encode.go:

func(dst io.Writer, src io.Reader) (err error) {
                var (
                        enc encodable
                        cb  func()
                )
                if _, err = utils.Catch(func() { enc, cb = getEncoder(algo, dst) }); err != nil {
                        return
                }
                defer func() {
                        if cb != nil {
                                cb()
                        }
                }()

                if _, err = io.Copy(enc, src); err != nil {
                        if err = utils.ErrIgnore(err, eofErrs...); err != nil {
                                return
                        }
                }
                err = enc.Flush()
                return utils.ErrIgnore(err, eofErrs...)
        }

func @54:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/decode.go:

func(dst io.Writer, src io.Reader) (err error) {
                var (
                        dec decodable
                        cb  func()
                )
                defer func() {
                        if cb != nil {
                                cb()
                        }
                }()

                if _, err = utils.Catch(func() { dec, cb = getDecoder(algo, src) }); err != nil {
                        return
                }

                _, err = io.Copy(dst, dec)
                return utils.ErrIgnore(err, eofErrs...)
        }

func @69:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/encode.go:

69	`func() {`
70	`if cb != nil {`
71	`cb()`
72	`}`
73	`}`

func @59:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/decode.go:

59	`func() {`
60	`if cb != nil {`
61	`cb()`
62	`}`
63	`}`

func EncodeStreamFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/encode.go:

func EncodeStreamFunc(algo Algorithm) func(dst io.Writer, src io.Reader) (err error) {
        return func(dst io.Writer, src io.Reader) (err error) {
                var (
                        enc encodable
                        cb  func()
                )
                if _, err = utils.Catch(func() { enc, cb = getEncoder(algo, dst) }); err != nil {
                        return
                }
                defer func() {
                        if cb != nil {
                                cb()
                        }
                }()

                if _, err = io.Copy(enc, src); err != nil {
                        if err = utils.ErrIgnore(err, eofErrs...); err != nil {
                                return
                        }
                }
                err = enc.Flush()
                return utils.ErrIgnore(err, eofErrs...)
        }
}

func @66:27

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/encode.go:

66	`func() { enc, cb = getEncoder(algo, dst) }`

func encoder.Reset

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/encode.go:

117	`func (e *encoder) Reset(w io.Writer) { e.enc.Reset(w) }`

func decoder.Reset

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/decode.go:

102	`func (e *decoder) Reset(r io.Reader) error { return e.dec.Reset(r) }`

func @65:27

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/decode.go:

65	`func() { dec, cb = getDecoder(algo, src) }`

func DecodeStreamFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/compress/decode.go:

func DecodeStreamFunc(algo Algorithm) func(dst io.Writer, src io.Reader) (err error) {
        return func(dst io.Writer, src io.Reader) (err error) {
                var (
                        dec decodable
                        cb  func()
                )
                defer func() {
                        if cb != nil {
                                cb()
                        }
                }()

                if _, err = utils.Catch(func() { dec, cb = getDecoder(algo, src) }); err != nil {
                        return
                }

                _, err = io.Copy(dst, dec)
                return utils.ErrIgnore(err, eofErrs...)
        }
}

Package Overview: github.com/wfusion/gofusion/common/utils/encode 84.3%

Please select a function to see what's left for testing.

`codecStream.Decode(...)`	`github.com/wfusion/gofusion/common/utils/encode/stream.go`	`100.0%`	`12/12`
`@193:9(...)`	`github.com/wfusion/gofusion/common/utils/encode/stream.go`	`100.0%`	`5/5`
`@46:9(...)`	`github.com/wfusion/gofusion/common/utils/encode/types.go`	`100.0%`	`4/4`
`codec.Decode(...)`	`github.com/wfusion/gofusion/common/utils/encode/codec.go`	`100.0%`	`4/4`
`codec.Encode(...)`	`github.com/wfusion/gofusion/common/utils/encode/codec.go`	`100.0%`	`4/4`
`@133:9(...)`	`github.com/wfusion/gofusion/common/utils/encode/stream.go`	`100.0%`	`3/3`
`decoder.Close(...)`	`github.com/wfusion/gofusion/common/utils/encode/stream.go`	`100.0%`	`2/2`
`encoder.Close(...)`	`github.com/wfusion/gofusion/common/utils/encode/stream.go`	`100.0%`	`2/2`
`Cipher(...)`	`github.com/wfusion/gofusion/common/utils/encode/types.go`	`100.0%`	`1/1`
`Compress(...)`	`github.com/wfusion/gofusion/common/utils/encode/types.go`	`100.0%`	`1/1`
`@38:26(...)`	`github.com/wfusion/gofusion/common/utils/encode/codec.go`	`100.0%`	`1/1`
`@55:9(...)`	`github.com/wfusion/gofusion/common/utils/encode/types.go`	`100.0%`	`1/1`
`encoder.Write(...)`	`github.com/wfusion/gofusion/common/utils/encode/stream.go`	`100.0%`	`1/1`
`newEncoder(...)`	`github.com/wfusion/gofusion/common/utils/encode/stream.go`	`100.0%`	`1/1`
`Encode(...)`	`github.com/wfusion/gofusion/common/utils/encode/types.go`	`100.0%`	`1/1`
`EncodedType.IsValid(...)`	`github.com/wfusion/gofusion/common/utils/encode/encode_type_enum.go`	`100.0%`	`1/1`
`decoder.Read(...)`	`github.com/wfusion/gofusion/common/utils/encode/stream.go`	`100.0%`	`1/1`
`newDecoder(...)`	`github.com/wfusion/gofusion/common/utils/encode/stream.go`	`100.0%`	`1/1`
`Algorithm.IsValid(...)`	`github.com/wfusion/gofusion/common/utils/encode/algorithm_enum.go`	`100.0%`	`1/1`
`Algorithm.String(...)`	`github.com/wfusion/gofusion/common/utils/encode/algorithm_enum.go`	`100.0%`	`1/1`
`@109:16(...)`	`github.com/wfusion/gofusion/common/utils/encode/stream.go`	`100.0%`	`1/1`
`@61:9(...)`	`github.com/wfusion/gofusion/common/utils/encode/types.go`	`100.0%`	`1/1`
`NewEncodeFunc(...)`	`github.com/wfusion/gofusion/common/utils/encode/stream.go`	`94.4%`	`17/18`
`NewDecodeFunc(...)`	`github.com/wfusion/gofusion/common/utils/encode/stream.go`	`94.4%`	`17/18`
`codecStream.Encode(...)`	`github.com/wfusion/gofusion/common/utils/encode/stream.go`	`91.7%`	`11/12`
`NewWriter(...)`	`github.com/wfusion/gofusion/common/utils/encode/stream.go`	`88.9%`	`8/9`
`From(...)`	`github.com/wfusion/gofusion/common/utils/encode/codec.go`	`87.5%`	`7/8`
`NewCodecStream(...)`	`github.com/wfusion/gofusion/common/utils/encode/stream.go`	`85.7%`	`6/7`
`parseEncodedType(...)`	`github.com/wfusion/gofusion/common/utils/encode/encode_type_enum.go`	`83.3%`	`5/6`
`NewReader(...)`	`github.com/wfusion/gofusion/common/utils/encode/stream.go`	`80.0%`	`8/10`
`codec.ToBytes(...)`	`github.com/wfusion/gofusion/common/utils/encode/codec.go`	`80.0%`	`4/5`
`codec.decode(...)`	`github.com/wfusion/gofusion/common/utils/encode/codec.go`	`78.6%`	`11/14`
`codec.encode(...)`	`github.com/wfusion/gofusion/common/utils/encode/codec.go`	`78.6%`	`11/14`
`codec.transform(...)`	`github.com/wfusion/gofusion/common/utils/encode/codec.go`	`75.0%`	`6/8`
`codec.ToString(...)`	`github.com/wfusion/gofusion/common/utils/encode/codec.go`	`75.0%`	`3/4`
`ParseAlgorithm(...)`	`github.com/wfusion/gofusion/common/utils/encode/algorithm_enum.go`	`50.0%`	`3/6`
`ParseEncodedType(...)`	`github.com/wfusion/gofusion/common/utils/encode/encode_type_enum.go`	`0.0%`	`0/6`
`EncodedType.Value(...)`	`github.com/wfusion/gofusion/common/utils/encode/encode_type_enum.go`	`0.0%`	`0/1`
`EncodedType.String(...)`	`github.com/wfusion/gofusion/common/utils/encode/encode_type_enum.go`	`0.0%`	`0/1`
`Algorithm.Value(...)`	`github.com/wfusion/gofusion/common/utils/encode/algorithm_enum.go`	`0.0%`	`0/1`

func codecStream.Decode

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/stream.go:

func (w *codecStream) Decode(dst io.Writer, src io.Reader) (n int64, err error) {
        for i := len(w.encodeOrder) - 1; i >= 0; i-- {
                switch w.encodeOrder[i] {
                case EncodedTypeCompress:
                        src = compress.NewDecFunc(w.o.compressAlgo)(src)
                case EncodedTypeCipher:
                        src = cipher.NewDecFunc(w.o.cipherAlgo, w.o.cipherMode, w.o.key, w.o.iv)(src)
                case EncodedTypeEncode:
                        src = NewReader(w.o.printableAlgo, src)
                }
        }

        buf, cb := utils.BytesPool.Get(defaultBufferSize)
        defer cb()
        defer utils.CloseAnyway(src)
        n, err = io.CopyBuffer(dst, src, buf)
        if errors.Is(err, io.ErrUnexpectedEOF) || errors.Is(err, io.EOF) {
                err = nil
        }
        return
}

func @193:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/stream.go:

func(src []byte) (dst []byte, err error) {
                dst = make([]byte, decodedLenFunc(len(src)))
                n, err := decodeFunc(dst, src)
                if err == nil {
                        dst = dst[:n]
                }
                return
        }

func @46:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/types.go:

func(o *option) {
                o.cipherAlgo = algo
                o.cipherMode = mode
                o.key = clone.SliceComparable(key)
                o.iv = clone.SliceComparable(iv)
        }

func codec.Decode

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/codec.go:

func (c *codec) Decode(opts ...utils.OptionExtender) Codecable {
        for i, p := 0, len(c.decOpts); i < len(opts); i++ {
                c.queue = append(c.queue, [2]int{p + i, 1})
        }
        c.decOpts = append(c.decOpts, opts...)
        return c
}

func codec.Encode

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/codec.go:

func (c *codec) Encode(opts ...utils.OptionExtender) Codecable {
        for i, p := 0, len(c.encOpts); i < len(opts); i++ {
                c.queue = append(c.queue, [2]int{p + i, 0})
        }
        c.encOpts = append(c.encOpts, opts...)
        return c
}

func @133:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/stream.go:

func(src []byte) (dst []byte, err error) {
                dst = make([]byte, encodedLenFunc(len(src)))
                encodeFunc(dst, src)
                return
        }

func decoder.Close

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/stream.go:

212	`func (e *decoder) Close() { utils.CloseAnyway(e.r); utils.CloseAnyway(e.dec) }`

func encoder.Close

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/stream.go:

223	`func (e *encoder) Close() { utils.CloseAnyway(e.enc); utils.CloseAnyway(e.w) }`

func Cipher

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/types.go:

func Cipher(algo cipher.Algorithm, mode cipher.Mode, key, iv []byte) utils.OptionFunc[option] {
        return func(o *option) {
                o.cipherAlgo = algo
                o.cipherMode = mode
                o.key = clone.SliceComparable(key)
                o.iv = clone.SliceComparable(iv)
        }
}

func Compress

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/types.go:

func Compress(algo compress.Algorithm) utils.OptionFunc[option] {
        return func(o *option) {
                o.compressAlgo = algo
        }
}

func @38:26

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/codec.go:

38	`func(c *codec) { c.release() }`

func @55:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/types.go:

55	`func(o *option) {`
56	`o.compressAlgo = algo`
57	`}`

func encoder.Write

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/stream.go:

222	`func (e *encoder) Write(p []byte) (n int, err error) { return e.enc.Write(p) }`

func newEncoder

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/stream.go:

218	`func newEncoder(enc, w io.Writer) io.Writer {`
219	`return &encoder{enc: enc, w: w}`
220	`}`

func Encode

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/types.go:

func Encode(algo Algorithm) utils.OptionFunc[option] {
        return func(o *option) {
                o.printableAlgo = algo
        }
}

func EncodedType.IsValid

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/encode_type_enum.go:

36	`func (e EncodedType) IsValid() bool {`
37	`return encodeTypeEnum.IsValid(e)`
38	`}`

func decoder.Read

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/stream.go:

211	`func (e *decoder) Read(p []byte) (n int, err error) { return e.dec.Read(p) }`

func newDecoder

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/stream.go:

207	`func newDecoder(dec, r io.Reader) io.Reader {`
208	`return &decoder{dec: dec, r: r}`
209	`}`

func Algorithm.IsValid

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/algorithm_enum.go:

45	`func (e Algorithm) IsValid() bool {`
46	`return algorithmEnum.IsValid(e)`
47	`}`

func Algorithm.String

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/algorithm_enum.go:

41	`func (e Algorithm) String() string {`
42	`return algorithmEnum.String(e)`
43	`}`

func @109:16

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/stream.go:

109	`func(src, dst []byte) { hex.Encode(src, dst) }`

func @61:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/types.go:

61	`func(o *option) {`
62	`o.printableAlgo = algo`
63	`}`

func NewEncodeFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/stream.go:

func NewEncodeFunc(algo Algorithm) func([]byte) ([]byte, error) {
        var (
                encodeFunc     func(src, dst []byte)
                encodedLenFunc func(int) int
        )
        switch algo {
        case AlgorithmHex:
                encodeFunc = func(src, dst []byte) { hex.Encode(src, dst) }
                encodedLenFunc = hex.EncodedLen
        case AlgorithmBase32Std:
                encodeFunc = base32.StdEncoding.Encode
                encodedLenFunc = base32.StdEncoding.EncodedLen
        case AlgorithmBase32Hex:
                encodeFunc = base32.HexEncoding.Encode
                encodedLenFunc = base32.HexEncoding.EncodedLen
        case AlgorithmBase64Std:
                encodeFunc = base64.StdEncoding.Encode
                encodedLenFunc = base64.StdEncoding.EncodedLen
        case AlgorithmBase64URL:
                encodeFunc = base64.URLEncoding.Encode
                encodedLenFunc = base64.URLEncoding.EncodedLen
        case AlgorithmBase64RawStd:
                encodeFunc = base64.RawStdEncoding.Encode
                encodedLenFunc = base64.RawStdEncoding.EncodedLen
        case AlgorithmBase64RawURL:
                encodeFunc = base64.RawURLEncoding.Encode
                encodedLenFunc = base64.RawURLEncoding.EncodedLen
        default:
                panic(ErrUnknownAlgorithm)
        }

        return func(src []byte) (dst []byte, err error) {
                dst = make([]byte, encodedLenFunc(len(src)))
                encodeFunc(dst, src)
                return
        }
}

func NewDecodeFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/stream.go:

func NewDecodeFunc(algo Algorithm) func([]byte) ([]byte, error) {
        var (
                decodeFunc     func(src, dst []byte) (int, error)
                decodedLenFunc func(int) int
        )
        switch algo {
        case AlgorithmHex:
                decodeFunc = hex.Decode
                decodedLenFunc = hex.DecodedLen
        case AlgorithmBase32Std:
                decodeFunc = base32.StdEncoding.Decode
                decodedLenFunc = base32.StdEncoding.DecodedLen
        case AlgorithmBase32Hex:
                decodeFunc = base32.HexEncoding.Decode
                decodedLenFunc = base32.HexEncoding.DecodedLen
        case AlgorithmBase64Std:
                decodeFunc = base64.StdEncoding.Decode
                decodedLenFunc = base64.StdEncoding.DecodedLen
        case AlgorithmBase64URL:
                decodeFunc = base64.URLEncoding.Decode
                decodedLenFunc = base64.URLEncoding.DecodedLen
        case AlgorithmBase64RawStd:
                decodeFunc = base64.RawStdEncoding.Decode
                decodedLenFunc = base64.RawStdEncoding.DecodedLen
        case AlgorithmBase64RawURL:
                decodeFunc = base64.RawURLEncoding.Decode
                decodedLenFunc = base64.RawURLEncoding.DecodedLen
        default:
                panic(ErrUnknownAlgorithm)
        }

        return func(src []byte) (dst []byte, err error) {
                dst = make([]byte, decodedLenFunc(len(src)))
                n, err := decodeFunc(dst, src)
                if err == nil {
                        dst = dst[:n]
                }
                return
        }
}

func codecStream.Encode

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/stream.go:

func (w *codecStream) Encode(dst io.Writer, src io.Reader) (n int64, err error) {
        for i := len(w.encodeOrder) - 1; i >= 0; i-- {
                switch w.encodeOrder[i] {
                case EncodedTypeCompress:
                        dst = compress.NewEncFunc(w.o.compressAlgo)(dst)
                case EncodedTypeCipher:
                        dst = cipher.NewEncFunc(w.o.cipherAlgo, w.o.cipherMode, w.o.key, w.o.iv)(dst)
                case EncodedTypeEncode:
                        dst = NewWriter(w.o.printableAlgo, dst)
                }
        }

        buf, cb := utils.BytesPool.Get(defaultBufferSize)
        defer cb()

        defer utils.CloseAnyway(dst)
        n, err = io.CopyBuffer(dst, src, buf)
        if errors.Is(err, io.ErrUnexpectedEOF) || errors.Is(err, io.EOF) {
                err = nil
        }
        return
}

func NewWriter

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/stream.go:

func NewWriter(algo Algorithm, w io.Writer) io.Writer {
        switch algo {
        case AlgorithmHex:
                return newEncoder(hex.NewEncoder(w), w)
        case AlgorithmBase32Std:
                return newEncoder(base32.NewEncoder(base32.StdEncoding, w), w)
        case AlgorithmBase32Hex:
                return newEncoder(base32.NewEncoder(base32.HexEncoding, w), w)
        case AlgorithmBase64Std:
                return newEncoder(base64.NewEncoder(base64.StdEncoding, w), w)
        case AlgorithmBase64URL:
                return newEncoder(base64.NewEncoder(base64.URLEncoding, w), w)
        case AlgorithmBase64RawStd:
                return newEncoder(base64.NewEncoder(base64.RawStdEncoding, w), w)
        case AlgorithmBase64RawURL:
                return newEncoder(base64.NewEncoder(base64.RawURLEncoding, w), w)
        default:
                panic(ErrUnknownAlgorithm)
        }
}

func From

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/codec.go:

func From[T ~[]byte | ~string](src T) (c Codecable) {
        buf, cb := utils.BytesBufferPool.Get(nil)

        switch v := any(src).(type) {
        case []byte:
                buf.Write(v)
        case string:
                buf.WriteString(v)
        default:
                buf.Write([]byte(src))
        }

        c = &codec{
                buf:     buf,
                release: cb,
        }

        runtime.SetFinalizer(c, func(c *codec) { c.release() })
        return
}

func NewCodecStream

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/stream.go:

func NewCodecStream(opts ...utils.OptionExtender) Streamable {
        encodeOrder := make([]EncodedType, 0, len(opts))
        for _, opt := range opts {
                if encType := parseEncodedType(opt); encType.IsValid() {
                        encodeOrder = append(encodeOrder, encType)
                }
        }
        if len(encodeOrder) == 0 {
                panic(ErrEncodeMethodNotFound)
        }
        return &codecStream{
                o:           utils.ApplyOptions[option](opts...),
                encodeOrder: encodeOrder,
        }
}

func parseEncodedType

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/encode_type_enum.go:

func parseEncodedType(one utils.OptionExtender) EncodedType {
        opts := utils.ApplyOptions[option](one)
        switch {
        case opts.cipherAlgo.IsValid():
                return EncodedTypeCipher
        case opts.compressAlgo.IsValid():
                return EncodedTypeCompress
        case opts.printableAlgo.IsValid():
                return EncodedTypeEncode
        default:
                return EncodedTypeUnknown
        }
}

func NewReader

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/stream.go:

func NewReader(algo Algorithm, r io.Reader) io.Reader {
        switch algo {
        case AlgorithmHex:
                return newDecoder(hex.NewDecoder(r), r)
        case AlgorithmBase32Std:
                return newDecoder(base32.NewDecoder(base32.StdEncoding, r), r)
        case AlgorithmBase32Hex:
                return newDecoder(base32.NewDecoder(base32.HexEncoding, r), r)
        case AlgorithmBase64Std:
                return newDecoder(base64.NewDecoder(base64.StdEncoding, r), r)
        case AlgorithmBase64URL:
                return newDecoder(base64.NewDecoder(base64.URLEncoding, r), r)
        case AlgorithmBase64RawStd:
                return newDecoder(base64.NewDecoder(base64.RawStdEncoding, r), r)
        case AlgorithmBase64RawURL:
                return newDecoder(base64.NewDecoder(base64.RawURLEncoding, r), r)
        default:
                panic(ErrUnknownAlgorithm)
        }
        return nil
}

func codec.ToBytes

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/codec.go:

func (c *codec) ToBytes() (dst []byte, err error) {
        if err = c.transform(); err != nil {
                return
        }
        dst = make([]byte, c.buf.Len())
        copy(dst, c.buf.Bytes())
        return
}

func codec.decode

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/codec.go:

func (c *codec) decode(opt utils.OptionExtender) (err error) {
        var dec func([]byte) ([]byte, error)

        switch option := utils.ApplyOptions[option](opt); parseEncodedType(opt) {
        case EncodedTypeCompress:
                dec = compress.DecodeBytesFunc(option.compressAlgo)
        case EncodedTypeCipher:
                dec, err = cipher.DecryptBytesFunc(option.cipherAlgo, option.cipherMode, option.key, option.iv)
        case EncodedTypeEncode:
                dec = NewDecodeFunc(option.printableAlgo)
        default:
                return ErrEncodeMethodNotFound
        }
        if err != nil {
                return
        }

        dst, err := dec(c.buf.Bytes())
        if err != nil {
                return
        }
        c.buf.Reset()
        c.buf.Write(dst)
        return
}

func codec.encode

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/codec.go:

func (c *codec) encode(opt utils.OptionExtender) (err error) {
        var enc func([]byte) ([]byte, error)

        switch option := utils.ApplyOptions[option](opt); parseEncodedType(opt) {
        case EncodedTypeCompress:
                enc = compress.EncodeBytesFunc(option.compressAlgo)
        case EncodedTypeCipher:
                enc, err = cipher.EncryptBytesFunc(option.cipherAlgo, option.cipherMode, option.key, option.iv)
        case EncodedTypeEncode:
                enc = NewEncodeFunc(option.printableAlgo)
        default:
                return ErrEncodeMethodNotFound
        }
        if err != nil {
                return
        }

        dst, err := enc(c.buf.Bytes())
        if err != nil {
                return
        }
        c.buf.Reset()
        c.buf.Write(dst)
        return
}

func codec.transform

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/codec.go:

func (c *codec) transform() (err error) {
        for _, elem := range c.queue {
                idx, isEnc := elem[0], elem[1] == 0
                if isEnc {
                        if err = c.encode(c.encOpts[idx]); err != nil {
                                return
                        }
                } else {
                        if err = c.decode(c.decOpts[idx]); err != nil {
                                return
                        }

                }
        }

        return
}

func codec.ToString

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/codec.go:

func (c *codec) ToString() (dst string, err error) {
        if err = c.transform(); err != nil {
                return
        }
        dst = c.buf.String()
        return
}

func ParseAlgorithm

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/algorithm_enum.go:

func ParseAlgorithm(s any) Algorithm {
        switch v := s.(type) {
        case string:
                if enumList := algorithmEnum.Enum(v); len(enumList) > 0 {
                        return enumList[0]
                }
        case Algorithm:
                return v
        default:
                return Algorithm(cast.ToInt(s))
        }
        return AlgorithmUnknown
}

func ParseEncodedType

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/encode_type_enum.go:

func ParseEncodedType(s any) EncodedType {
        switch v := s.(type) {
        case string:
                if enumList := encodeTypeEnum.Enum(v); len(enumList) > 0 {
                        return enumList[0]
                }
        case EncodedType:
                return v
        default:
                return EncodedType(cast.ToInt(s))
        }
        return EncodedTypeUnknown
}

func EncodedType.Value

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/encode_type_enum.go:

28	`func (e EncodedType) Value() uint8 {`
29	`return uint8(e)`
30	`}`

func EncodedType.String

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/encode_type_enum.go:

32	`func (e EncodedType) String() string {`
33	`return encodeTypeEnum.String(e)`
34	`}`

func Algorithm.Value

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/encode/algorithm_enum.go:

37	`func (e Algorithm) Value() uint8 {`
38	`return uint8(e)`
39	`}`

Package Overview: github.com/wfusion/gofusion/common/utils/inspect 67.7%

Please select a function to see what's left for testing.

`@95:17(...)`	`github.com/wfusion/gofusion/common/utils/inspect/inspect.go`	`100.0%`	`5/5`
`init(...)`	`github.com/wfusion/gofusion/common/utils/inspect/inspect.go`	`100.0%`	`4/4`
`packType(...)`	`github.com/wfusion/gofusion/common/utils/inspect/rtype.go`	`100.0%`	`3/3`
`Field.read(...)`	`github.com/wfusion/gofusion/common/utils/inspect/field.go`	`100.0%`	`3/3`
`Field.addr(...)`	`github.com/wfusion/gofusion/common/utils/inspect/field.go`	`100.0%`	`3/3`
`@106:17(...)`	`github.com/wfusion/gofusion/common/utils/inspect/inspect.go`	`100.0%`	`3/3`
`derefValue(...)`	`github.com/wfusion/gofusion/common/utils/inspect/field.go`	`100.0%`	`3/3`
`eface.pack(...)`	`github.com/wfusion/gofusion/common/utils/inspect/rtype.go`	`100.0%`	`2/2`
`@71:14(...)`	`github.com/wfusion/gofusion/common/utils/inspect/rtype.go`	`100.0%`	`2/2`
`GetField(...)`	`github.com/wfusion/gofusion/common/utils/inspect/field_go118.go`	`100.0%`	`2/2`
`SetField(...)`	`github.com/wfusion/gofusion/common/utils/inspect/field_go118.go`	`100.0%`	`1/1`
`newField(...)`	`github.com/wfusion/gofusion/common/utils/inspect/field.go`	`100.0%`	`1/1`
`unpackType(...)`	`github.com/wfusion/gofusion/common/utils/inspect/rtype.go`	`100.0%`	`1/1`
`enumerateTypes(...)`	`github.com/wfusion/gofusion/common/utils/inspect/init_go118.go`	`91.7%`	`11/12`
`enumerateFuncs(...)`	`github.com/wfusion/gofusion/common/utils/inspect/init_go118.go`	`85.7%`	`6/7`
`TypeOf(...)`	`github.com/wfusion/gofusion/common/utils/inspect/inspect.go`	`80.0%`	`4/5`
`FuncOf(...)`	`github.com/wfusion/gofusion/common/utils/inspect/inspect.go`	`80.0%`	`4/5`
`Field.Set(...)`	`github.com/wfusion/gofusion/common/utils/inspect/field.go`	`75.0%`	`3/4`
`FieldByName(...)`	`github.com/wfusion/gofusion/common/utils/inspect/field_go118.go`	`66.7%`	`2/3`
`mustOk(...)`	`github.com/wfusion/gofusion/common/utils/inspect/misc_go118.go`	`66.7%`	`2/3`
`Field.Get(...)`	`github.com/wfusion/gofusion/common/utils/inspect/field.go`	`66.7%`	`2/3`
`@80:17(...)`	`github.com/wfusion/gofusion/common/utils/inspect/inspect.go`	`0.0%`	`0/4`
`@56:17(...)`	`github.com/wfusion/gofusion/common/utils/inspect/inspect.go`	`0.0%`	`0/4`
`getField(...)`	`github.com/wfusion/gofusion/common/utils/inspect/field_go118.go`	`0.0%`	`0/3`
`FieldAt(...)`	`github.com/wfusion/gofusion/common/utils/inspect/field_go118.go`	`0.0%`	`0/3`
`derefType(...)`	`github.com/wfusion/gofusion/common/utils/inspect/field.go`	`0.0%`	`0/3`
`setField(...)`	`github.com/wfusion/gofusion/common/utils/inspect/field_go118.go`	`0.0%`	`0/3`
`RuntimeFuncOf(...)`	`github.com/wfusion/gofusion/common/utils/inspect/inspect.go`	`0.0%`	`0/2`
`RuntimeTypeOf(...)`	`github.com/wfusion/gofusion/common/utils/inspect/inspect.go`	`0.0%`	`0/2`

func @95:17

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/inspect/inspect.go:

func(typ reflect.Type) bool {
                pkgName := typ.PkgPath()
                typeName := typ.Name()
                if pkgName != "" && typeName != "" {
                        structs[pkgName+"."+typeName] = typ
                }

                return true
        }

func init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/inspect/inspect.go:

func init() {
        lock.Lock()
        defer lock.Unlock()

        // inspect structs
        enumerateTypes(func(typ reflect.Type) bool {
                pkgName := typ.PkgPath()
                typeName := typ.Name()
                if pkgName != "" && typeName != "" {
                        structs[pkgName+"."+typeName] = typ
                }

                return true
        })

        // inspect function
        enumerateFuncs(func(fn *runtime.Func, addr uintptr) bool {
                if funcName := fn.Name(); funcName != "" {
                        funcs[funcName] = unsafe.Pointer(&addr)
                }
                return true
        })
}

func packType

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/inspect/rtype.go:

func packType(t *rtype) (r reflect.Type) {
        (*iface)(unsafe.Pointer(&r)).tab = itabRtype
        (*iface)(unsafe.Pointer(&r)).data = unsafe.Pointer(t)
        return
}

func Field.read

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/inspect/field.go:

func (f Field) read() eface {
        if ifaceIndir(f.t) {
                return eface{_type: f.t, data: f.p}
        } else {
                return eface{_type: f.t, data: *(*unsafe.Pointer)(f.p)}
        }
}

func Field.addr

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/inspect/field.go:

func (f Field) addr(v reflect.Value) unsafe.Pointer {
        if ifaceIndir(f.t) {
                return (*eface)(unsafe.Pointer(&v)).data
        } else {
                return unsafe.Pointer(&((*eface)(unsafe.Pointer(&v)).data))
        }
}

func @106:17

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/inspect/inspect.go:

func(fn *runtime.Func, addr uintptr) bool {
                if funcName := fn.Name(); funcName != "" {
                        funcs[funcName] = unsafe.Pointer(&addr)
                }
                return true
        }

func derefValue

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/inspect/field.go:

func derefValue(t reflect.Value) reflect.Value {
        for t.Kind() == reflect.Ptr {
                t = t.Elem()
        }
        return t
}

func eface.pack

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/inspect/rtype.go:

25	`func (e eface) pack() (r interface{}) { (eface)(unsafe.Pointer(&r)) = e; return }`

func @71:14

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/inspect/rtype.go:

71	`func(v interface{}) *itab {`
72	`t := reflect.TypeOf(v).Elem()`
73	`return (*iface)(unsafe.Pointer(&t)).tab`
74	`}`

func GetField

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/inspect/field_go118.go:

35	`func GetField[T any](obj any, fieldName string) (r T) {`
36	`r, _ = mustOk(FieldByName(derefValue(reflect.ValueOf(obj)), fieldName)).Get().Interface().(T)`
37	`return`
38	`}`

func SetField

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/inspect/field_go118.go:

31	`func SetField[T any](obj any, fieldName string, val T) {`
32	`mustOk(FieldByName(derefValue(reflect.ValueOf(obj)), fieldName)).Set(reflect.ValueOf(val))`
33	`}`

func newField

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/inspect/field.go:

func newField(v reflect.Value, fv reflect.StructField) Field {
        return Field{
                t: unpackType(fv.Type),
                p: unsafe.Pointer(uintptr((*eface)(unsafe.Pointer(&v)).data) + fv.Offset),
        }
}

func unpackType

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/inspect/rtype.go:

77	`func unpackType(t reflect.Type) *rtype {`
78	`return (rtype)((eface)(unsafe.Pointer(&t)).data)`
79	`}`

func enumerateTypes

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/inspect/init_go118.go:

func enumerateTypes(cb func(reflect.Type) bool) {
        t0 := reflect.TypeOf(struct{}{})
        sections, typeLinks := typelinks()
        for i, typeLink := range typeLinks {
                for _, link := range typeLink {
                        (*eface)(unsafe.Pointer(&t0)).data = resolveTypeOff(sections[i], link)
                        if t0.Kind() != reflect.Ptr || !supportTypes[t0.Elem().Kind()] {
                                continue
                        }
                        typ := t0.Elem()
                        if typ.PkgPath() == "" || typ.Name() == "" {
                                continue
                        }
                        if !cb(typ) {
                                return
                        }
                }
        }
}

func enumerateFuncs

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/inspect/init_go118.go:

func enumerateFuncs(cb func(*runtime.Func, uintptr) bool) {
        for _, md := range activeModules() {
                for _, tab := range md.ftab {
                        f := tab // should not take from &tab.entry because go syntax
                        absoluteAddr := textAddr(md, f.entry)
                        if fn := runtime.FuncForPC(absoluteAddr); fn != nil {
                                if !cb(fn, absoluteAddr) {
                                        return
                                }
                        }
                }
        }
}

func TypeOf

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/inspect/inspect.go:

func TypeOf(typeName string) reflect.Type {
        lock.RLock()
        defer lock.RUnlock()
        if typ, ok := structs[typeName]; ok {
                return typ
        }
        return nil
}

func FuncOf

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/inspect/inspect.go:

func FuncOf(funcName string) unsafe.Pointer {
        lock.RLock()
        defer lock.RUnlock()
        if entry, ok := funcs[funcName]; ok {
                return unsafe.Pointer(&entry)
        }
        return nil
}

func Field.Set

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/inspect/field.go:

func (f Field) Set(v reflect.Value) {
        if f.t == nil {
                panic(errors.New("inspect: invalid field"))
        }

        v = v.Convert(packType(f.t))
        typedmemmove(f.t, f.p, f.addr(v))
}

func FieldByName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/inspect/field_go118.go:

func FieldByName(v reflect.Value, name string) (Field, bool) {
        if fv, ok := v.Type().FieldByName(name); !ok {
                return Field{}, false
        } else {
                return newField(v, fv), true
        }
}

func mustOk

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/inspect/misc_go118.go:

func mustOk[T any](out T, ok bool) T {
        if !ok {
                panic(errors.Errorf("get %T with ok is false", out))
        }
        return out
}

func Field.Get

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/inspect/field.go:

func (f Field) Get() reflect.Value {
        if f.t == nil {
                panic(errors.New("inspect: invalid field"))
        }
        return reflect.ValueOf(f.read().pack())
}

func @80:17

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/inspect/inspect.go:

func(fn *runtime.Func, addr uintptr) bool {
                if fn.Name() == funcName {
                        r = unsafe.Pointer(&addr)
                        return false
                }
                return true
        }

func @56:17

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/inspect/inspect.go:

func(typ reflect.Type) bool {
                if typ.PkgPath()+"."+typ.Name() == typeName {
                        r = typ
                        return false
                }
                return true
        }

func getField

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/inspect/field_go118.go:

func getField[T any](obj any, fieldName string) (r T) {
        v := reflect.Indirect(reflect.ValueOf(obj))
        r, _ = valueInterface(v.FieldByName(fieldName), false).(T)
        return
}

func FieldAt

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/inspect/field_go118.go:

func FieldAt(v reflect.Value, idx int) (Field, bool) {
        if idx < 0 || idx >= v.NumField() {
                return Field{}, false
        } else {
                return newField(v, v.Type().Field(idx)), true
        }
}

func derefType

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/inspect/field.go:

func derefType(t reflect.Type) reflect.Type {
        for t.Kind() == reflect.Ptr {
                t = t.Elem()
        }
        return t
}

func setField

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/inspect/field_go118.go:

func setField[T any](obj any, fieldName string, val T) {
        v := reflect.ValueOf(obj)
        t := reflect.Indirect(v).Type()
        *(*T)(unsafe.Pointer(v.Pointer() + mustOk(t.FieldByName(fieldName)).Offset)) = val
}

func RuntimeFuncOf

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/inspect/inspect.go:

func RuntimeFuncOf(funcName string) (r unsafe.Pointer) {
        enumerateFuncs(func(fn *runtime.Func, addr uintptr) bool {
                if fn.Name() == funcName {
                        r = unsafe.Pointer(&addr)
                        return false
                }
                return true
        })
        return
}

func RuntimeTypeOf

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/inspect/inspect.go:

func RuntimeTypeOf(typeName string) (r reflect.Type) {
        enumerateTypes(func(typ reflect.Type) bool {
                if typ.PkgPath()+"."+typ.Name() == typeName {
                        r = typ
                        return false
                }
                return true
        })
        return
}

Package Overview: github.com/wfusion/gofusion/common/utils/serialize 66.7%

Please select a function to see what's left for testing.

`@17:9(...)`	`github.com/wfusion/gofusion/common/utils/serialize/unmarshal.go`	`100.0%`	`5/5`
`@19:18(...)`	`github.com/wfusion/gofusion/common/utils/serialize/types.go`	`100.0%`	`5/5`
`@27:21(...)`	`github.com/wfusion/gofusion/common/utils/serialize/types.go`	`100.0%`	`4/4`
`@52:21(...)`	`github.com/wfusion/gofusion/common/utils/serialize/types.go`	`100.0%`	`3/3`
`@55:9(...)`	`github.com/wfusion/gofusion/common/utils/serialize/unmarshal.go`	`100.0%`	`2/2`
`@57:18(...)`	`github.com/wfusion/gofusion/common/utils/serialize/types.go`	`100.0%`	`1/1`
`Algorithm.Value(...)`	`github.com/wfusion/gofusion/common/utils/serialize/algorithm_enum.go`	`100.0%`	`1/1`
`@36:9(...)`	`github.com/wfusion/gofusion/common/utils/serialize/marshal.go`	`100.0%`	`1/1`
`@16:17(...)`	`github.com/wfusion/gofusion/common/utils/serialize/types.go`	`100.0%`	`1/1`
`Algorithm.IsValid(...)`	`github.com/wfusion/gofusion/common/utils/serialize/algorithm_enum.go`	`100.0%`	`1/1`
`Algorithm.String(...)`	`github.com/wfusion/gofusion/common/utils/serialize/algorithm_enum.go`	`100.0%`	`1/1`
`@33:18(...)`	`github.com/wfusion/gofusion/common/utils/serialize/types.go`	`100.0%`	`1/1`
`@39:17(...)`	`github.com/wfusion/gofusion/common/utils/serialize/types.go`	`100.0%`	`1/1`
`@83:9(...)`	`github.com/wfusion/gofusion/common/utils/serialize/types.go`	`100.0%`	`1/1`
`JsonEscapeHTML(...)`	`github.com/wfusion/gofusion/common/utils/serialize/types.go`	`100.0%`	`1/1`
`@16:9(...)`	`github.com/wfusion/gofusion/common/utils/serialize/marshal.go`	`85.7%`	`6/7`
`ParseAlgorithm(...)`	`github.com/wfusion/gofusion/common/utils/serialize/algorithm_enum.go`	`83.3%`	`5/6`
`UnmarshalStreamFunc(...)`	`github.com/wfusion/gofusion/common/utils/serialize/unmarshal.go`	`80.0%`	`4/5`
`MarshalFunc(...)`	`github.com/wfusion/gofusion/common/utils/serialize/marshal.go`	`80.0%`	`4/5`
`UnmarshalFunc(...)`	`github.com/wfusion/gofusion/common/utils/serialize/unmarshal.go`	`80.0%`	`4/5`
`MarshalStreamFunc(...)`	`github.com/wfusion/gofusion/common/utils/serialize/marshal.go`	`80.0%`	`4/5`
`@71:9(...)`	`github.com/wfusion/gofusion/common/utils/serialize/unmarshal.go`	`80.0%`	`4/5`
`UnmarshalStreamFuncByType(...)`	`github.com/wfusion/gofusion/common/utils/serialize/unmarshal.go`	`75.0%`	`6/8`
`@42:18(...)`	`github.com/wfusion/gofusion/common/utils/serialize/types.go`	`66.7%`	`4/6`
`UnmarshalFuncByType(...)`	`github.com/wfusion/gofusion/common/utils/serialize/unmarshal.go`	`0.0%`	`0/8`
`@37:9(...)`	`github.com/wfusion/gofusion/common/utils/serialize/unmarshal.go`	`0.0%`	`0/6`
`JsonIndent(...)`	`github.com/wfusion/gofusion/common/utils/serialize/types.go`	`0.0%`	`0/1`
`@106:9(...)`	`github.com/wfusion/gofusion/common/utils/serialize/types.go`	`0.0%`	`0/1`
`@77:9(...)`	`github.com/wfusion/gofusion/common/utils/serialize/types.go`	`0.0%`	`0/1`
`@71:9(...)`	`github.com/wfusion/gofusion/common/utils/serialize/types.go`	`0.0%`	`0/1`
`DisallowUnknownFields(...)`	`github.com/wfusion/gofusion/common/utils/serialize/types.go`	`0.0%`	`0/1`
`@100:9(...)`	`github.com/wfusion/gofusion/common/utils/serialize/types.go`	`0.0%`	`0/1`
`MsgpackUseCompactInts(...)`	`github.com/wfusion/gofusion/common/utils/serialize/types.go`	`0.0%`	`0/1`
`JsonNumber(...)`	`github.com/wfusion/gofusion/common/utils/serialize/types.go`	`0.0%`	`0/1`
`@89:9(...)`	`github.com/wfusion/gofusion/common/utils/serialize/types.go`	`0.0%`	`0/1`
`MsgpackUseCompactFloats(...)`	`github.com/wfusion/gofusion/common/utils/serialize/types.go`	`0.0%`	`0/1`

func @17:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/unmarshal.go:

func(src []byte) (dst T, err error) {
                bs, cb := utils.BytesBufferPool.Get(nil)
                defer cb()

                bs.Write(src)
                err = fn(&dst, bs, opt)
                return
        }

func @19:18

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/types.go:

func(dst io.Writer, src any, opt *marshalOption) (err error) {
                        enc := json.NewEncoder(dst)
                        if !opt.jsonEscapeHTML {
                                enc.SetEscapeHTML(false)
                        }
                        enc.SetIndent(opt.jsonIndentPrefix, opt.jsonIndent)
                        return enc.Encode(src)
                }

func @27:21

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/types.go:

func(dst io.Writer, src any, opt *marshalOption) (err error) {
                        enc := msgpack.NewEncoder(dst)
                        enc.UseCompactInts(opt.msgpackUseCompactInts)
                        enc.UseCompactFloats(opt.msgpackUseCompactFloats)
                        return enc.Encode(src)
                }

func @52:21

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/types.go:

func(dst any, src io.Reader, opt *unmarshalOption) (err error) {
                        dec := msgpack.NewDecoder(src)
                        dec.DisallowUnknownFields(opt.disallowUnknownFields)
                        return dec.Decode(dst)
                }

func @55:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/unmarshal.go:

55	`func(src io.Reader) (dst T, err error) {`
56	`err = fn(&dst, src, opt)`
57	`return`
58	`}`

func @57:18

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/types.go:

57	`func(dst any, src io.Reader, opt *unmarshalOption) (err error) {`
58	`return cbor.NewDecoder(src).Decode(dst)`
59	`}`

func Algorithm.Value

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/algorithm_enum.go:

31	`func (e Algorithm) Value() uint8 {`
32	`return uint8(e)`
33	`}`

func @36:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/marshal.go:

36	`func(dst io.Writer, src any) error {`
37	`return fn(dst, src, opt)`
38	`}`

func @16:17

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/types.go:

16	`func(dst io.Writer, src any, opt *marshalOption) (err error) {`
17	`return gob.NewEncoder(dst).Encode(src)`
18	`}`

func Algorithm.IsValid

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/algorithm_enum.go:

39	`func (e Algorithm) IsValid() bool {`
40	`return algorithmEnum.IsValid(e)`
41	`}`

func Algorithm.String

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/algorithm_enum.go:

35	`func (e Algorithm) String() string {`
36	`return algorithmEnum.String(e)`
37	`}`

func @33:18

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/types.go:

33	`func(dst io.Writer, src any, opt *marshalOption) (err error) {`
34	`return cbor.NewEncoder(dst).Encode(src)`
35	`}`

func @39:17

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/types.go:

39	`func(dst any, src io.Reader, opt *unmarshalOption) (err error) {`
40	`return gob.NewDecoder(src).Decode(dst)`
41	`}`

func @83:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/types.go:

83	`func(o *marshalOption) {`
84	`o.jsonEscapeHTML = on`
85	`}`

func JsonEscapeHTML

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/types.go:

func JsonEscapeHTML(on bool) utils.OptionFunc[marshalOption] {
        return func(o *marshalOption) {
                o.jsonEscapeHTML = on
        }
}

func @16:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/marshal.go:

func(src any) (dst []byte, err error) {
                bs, cb := utils.BytesBufferPool.Get(nil)
                defer cb()

                if err = fn(bs, src, opt); err != nil {
                        return
                }

                dst = make([]byte, bs.Len())
                copy(dst, bs.Bytes())
                return
        }

func ParseAlgorithm

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/algorithm_enum.go:

func ParseAlgorithm(s any) Algorithm {
        switch v := s.(type) {
        case string:
                if enumList := algorithmEnum.Enum(v); len(enumList) > 0 {
                        return enumList[0]
                }
        case Algorithm:
                return v
        default:
                return Algorithm(cast.ToInt(s))
        }
        return AlgorithmUnknown
}

func UnmarshalStreamFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/unmarshal.go:

func UnmarshalStreamFunc[T any](algo Algorithm, opts ...utils.OptionExtender) func(io.Reader) (T, error) {
        fn, ok := unmarshalFuncMap[algo]
        if !ok {
                panic(fmt.Errorf("unknown serialize algorithm type %+v", algo))
        }
        opt := utils.ApplyOptions[unmarshalOption](opts...)
        return func(src io.Reader) (dst T, err error) {
                err = fn(&dst, src, opt)
                return
        }
}

func MarshalFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/marshal.go:

func MarshalFunc(algo Algorithm, opts ...utils.OptionExtender) func(src any) ([]byte, error) {
        fn, ok := marshalFuncMap[algo]
        if !ok {
                panic(fmt.Errorf("unknown serialize algorithm type %+v", algo))
        }
        opt := utils.ApplyOptions[marshalOption](opts...)
        return func(src any) (dst []byte, err error) {
                bs, cb := utils.BytesBufferPool.Get(nil)
                defer cb()

                if err = fn(bs, src, opt); err != nil {
                        return
                }

                dst = make([]byte, bs.Len())
                copy(dst, bs.Bytes())
                return
        }
}

func UnmarshalFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/unmarshal.go:

func UnmarshalFunc[T any](algo Algorithm, opts ...utils.OptionExtender) func(src []byte) (T, error) {
        fn, ok := unmarshalFuncMap[algo]
        if !ok {
                panic(fmt.Errorf("unknown serialize algorithm type %+v", algo))
        }
        opt := utils.ApplyOptions[unmarshalOption](opts...)
        return func(src []byte) (dst T, err error) {
                bs, cb := utils.BytesBufferPool.Get(nil)
                defer cb()

                bs.Write(src)
                err = fn(&dst, bs, opt)
                return
        }
}

func MarshalStreamFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/marshal.go:

func MarshalStreamFunc(algo Algorithm, opts ...utils.OptionExtender) func(dst io.Writer, src any) error {
        fn, ok := marshalFuncMap[algo]
        if !ok {
                panic(fmt.Errorf("unknown serialize algorithm type %+v", algo))
        }
        opt := utils.ApplyOptions[marshalOption](opts...)
        return func(dst io.Writer, src any) error {
                return fn(dst, src, opt)
        }
}

func @71:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/unmarshal.go:

func(src io.Reader) (dst any, err error) {
                d := reflect.New(dstType).Interface()
                if err = fn(d, src, opt); err != nil {
                        return
                }
                dst = reflect.Indirect(reflect.ValueOf(d)).Interface()
                return
        }

func UnmarshalStreamFuncByType

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/unmarshal.go:

func UnmarshalStreamFuncByType(algo Algorithm, dst any, opts ...utils.OptionExtender) func(io.Reader) (any, error) {
        fn, ok := unmarshalFuncMap[algo]
        if !ok {
                panic(fmt.Errorf("unknown serialize algorithm type %+v", algo))
        }
        dstType, ok := dst.(reflect.Type)
        if !ok {
                dstType = reflect.TypeOf(dst)
        }
        opt := utils.ApplyOptions[unmarshalOption](opts...)
        return func(src io.Reader) (dst any, err error) {
                d := reflect.New(dstType).Interface()
                if err = fn(d, src, opt); err != nil {
                        return
                }
                dst = reflect.Indirect(reflect.ValueOf(d)).Interface()
                return
        }
}

func @42:18

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/types.go:

func(dst any, src io.Reader, opt *unmarshalOption) (err error) {
                        dec := json.NewDecoder(src)
                        if opt.jsonNumber {
                                dec.UseNumber()
                        }
                        if opt.disallowUnknownFields {
                                dec.DisallowUnknownFields()
                        }
                        return dec.Decode(dst)
                }

func UnmarshalFuncByType

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/unmarshal.go:

func UnmarshalFuncByType(algo Algorithm, dst any, opts ...utils.OptionExtender) func([]byte) (any, error) {
        fn, ok := unmarshalFuncMap[algo]
        if !ok {
                panic(fmt.Errorf("unknown serialize algorithm type %+v", algo))
        }
        dstType, ok := dst.(reflect.Type)
        if !ok {
                dstType = reflect.TypeOf(dst)
        }
        opt := utils.ApplyOptions[unmarshalOption](opts...)
        return func(src []byte) (dst any, err error) {
                dst = reflect.New(dstType).Interface()

                bs, cb := utils.BytesBufferPool.Get(nil)
                defer cb()

                bs.Write(src)
                err = fn(dst, bs, opt)
                return
        }
}

func @37:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/unmarshal.go:

func(src []byte) (dst any, err error) {
                dst = reflect.New(dstType).Interface()

                bs, cb := utils.BytesBufferPool.Get(nil)
                defer cb()

                bs.Write(src)
                err = fn(dst, bs, opt)
                return
        }

func JsonIndent

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/types.go:

func JsonIndent(prefix, indent string) utils.OptionFunc[marshalOption] {
        return func(o *marshalOption) {
                o.jsonIndentPrefix, o.jsonIndent = prefix, indent
        }
}

func @106:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/types.go:

106	`func(o *unmarshalOption) {`
107	`o.disallowUnknownFields = true`
108	`}`

func @77:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/types.go:

77	`func(o *marshalOption) {`
78	`o.msgpackUseCompactFloats = on`
79	`}`

func @71:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/types.go:

71	`func(o *marshalOption) {`
72	`o.msgpackUseCompactInts = on`
73	`}`

func DisallowUnknownFields

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/types.go:

func DisallowUnknownFields() utils.OptionFunc[unmarshalOption] {
        return func(o *unmarshalOption) {
                o.disallowUnknownFields = true
        }
}

func @100:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/types.go:

100	`func(o *unmarshalOption) {`
101	`o.jsonNumber = true`
102	`}`

func MsgpackUseCompactInts

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/types.go:

func MsgpackUseCompactInts(on bool) utils.OptionFunc[marshalOption] {
        return func(o *marshalOption) {
                o.msgpackUseCompactInts = on
        }
}

func JsonNumber

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/types.go:

func JsonNumber() utils.OptionFunc[unmarshalOption] {
        return func(o *unmarshalOption) {
                o.jsonNumber = true
        }
}

func @89:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/types.go:

89	`func(o *marshalOption) {`
90	`o.jsonIndentPrefix, o.jsonIndent = prefix, indent`
91	`}`

func MsgpackUseCompactFloats

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/common/utils/serialize/types.go:

func MsgpackUseCompactFloats(on bool) utils.OptionFunc[marshalOption] {
        return func(o *marshalOption) {
                o.msgpackUseCompactFloats = on
        }
}

Package Overview: github.com/wfusion/gofusion/config 79.5%

Please select a function to see what's left for testing.

`registry.initComponents(...)`	`github.com/wfusion/gofusion/config/registry.go`	`100.0%`	`21/21`
`@419:11(...)`	`github.com/wfusion/gofusion/config/registry.go`	`100.0%`	`14/14`
`registry.initByConfigFile(...)`	`github.com/wfusion/gofusion/config/registry.go`	`100.0%`	`12/12`
`registry.GetAllConfigs(...)`	`github.com/wfusion/gofusion/config/registry.go`	`100.0%`	`12/12`
`@112:16(...)`	`github.com/wfusion/gofusion/config/registry.go`	`100.0%`	`10/10`
`cryptoConf.cryptoConfuseKey(...)`	`github.com/wfusion/gofusion/config/crypto.go`	`100.0%`	`10/10`
`registry.Init(...)`	`github.com/wfusion/gofusion/config/registry.go`	`100.0%`	`9/9`
`New(...)`	`github.com/wfusion/gofusion/config/registry.go`	`100.0%`	`7/7`
`registry.initAllConfigByLoadFunc(...)`	`github.com/wfusion/gofusion/config/registry.go`	`100.0%`	`7/7`
`registry.makeAllConfigStruct(...)`	`github.com/wfusion/gofusion/config/registry.go`	`100.0%`	`6/6`
`CryptoConstruct(...)`	`github.com/wfusion/gofusion/config/crypto.go`	`100.0%`	`6/6`
`CryptoDecryptByTag(...)`	`github.com/wfusion/gofusion/config/crypto.go`	`100.0%`	`6/6`
`registry.makeComponentsConfigFields(...)`	`github.com/wfusion/gofusion/config/registry.go`	`100.0%`	`5/5`
`@355:26(...)`	`github.com/wfusion/gofusion/config/registry.go`	`100.0%`	`5/5`
`registry.AppName(...)`	`github.com/wfusion/gofusion/config/candy.go`	`100.0%`	`4/4`
`AddComponent(...)`	`github.com/wfusion/gofusion/config/component.go`	`100.0%`	`4/4`
`registry.Debug(...)`	`github.com/wfusion/gofusion/config/candy.go`	`100.0%`	`4/4`
`getComponents(...)`	`github.com/wfusion/gofusion/config/component.go`	`100.0%`	`3/3`
`registry.makeComponentsConfigStruct(...)`	`github.com/wfusion/gofusion/config/registry.go`	`100.0%`	`2/2`
`@96:9(...)`	`github.com/wfusion/gofusion/config/registry.go`	`100.0%`	`1/1`
`DI(...)`	`github.com/wfusion/gofusion/config/types.go`	`100.0%`	`1/1`
`@23:9(...)`	`github.com/wfusion/gofusion/config/types.go`	`100.0%`	`1/1`
`AppName(...)`	`github.com/wfusion/gofusion/config/types.go`	`100.0%`	`1/1`
`WithTag(...)`	`github.com/wfusion/gofusion/config/component.go`	`100.0%`	`1/1`
`@29:9(...)`	`github.com/wfusion/gofusion/config/types.go`	`100.0%`	`1/1`
`registry.DI(...)`	`github.com/wfusion/gofusion/config/candy.go`	`100.0%`	`1/1`
`@418:9(...)`	`github.com/wfusion/gofusion/config/registry.go`	`100.0%`	`1/1`
`registry.getBaseObject(...)`	`github.com/wfusion/gofusion/config/registry.go`	`100.0%`	`1/1`
`@361:34(...)`	`github.com/wfusion/gofusion/config/registry.go`	`100.0%`	`1/1`
`registry.loadComponents(...)`	`github.com/wfusion/gofusion/config/registry.go`	`100.0%`	`1/1`
`NewDefaultLoader(...)`	`github.com/wfusion/gofusion/config/loader.go`	`100.0%`	`1/1`
`loader.Unmarshal(...)`	`github.com/wfusion/gofusion/config/loader.go`	`100.0%`	`1/1`
`@40:23(...)`	`github.com/wfusion/gofusion/config/loader.go`	`100.0%`	`1/1`
`@136:16(...)`	`github.com/wfusion/gofusion/config/registry.go`	`100.0%`	`1/1`
`newOptions(...)`	`github.com/wfusion/gofusion/config/component.go`	`100.0%`	`1/1`
`@357:32(...)`	`github.com/wfusion/gofusion/config/registry.go`	`100.0%`	`1/1`
`@105:9(...)`	`github.com/wfusion/gofusion/config/component.go`	`100.0%`	`1/1`
`Ctx(...)`	`github.com/wfusion/gofusion/config/registry.go`	`100.0%`	`1/1`
`@84:9(...)`	`github.com/wfusion/gofusion/config/registry.go`	`100.0%`	`1/1`
`Loader(...)`	`github.com/wfusion/gofusion/config/registry.go`	`100.0%`	`1/1`
`@90:9(...)`	`github.com/wfusion/gofusion/config/registry.go`	`100.0%`	`1/1`
`Files(...)`	`github.com/wfusion/gofusion/config/registry.go`	`100.0%`	`1/1`
`@137:12(...)`	`github.com/wfusion/gofusion/config/registry.go`	`100.0%`	`1/1`
`init(...)`	`github.com/wfusion/gofusion/config/loader.go`	`100.0%`	`1/1`
`@192:35(...)`	`github.com/wfusion/gofusion/config/crypto.go`	`93.8%`	`15/16`
`registry.AddComponent(...)`	`github.com/wfusion/gofusion/config/registry.go`	`93.1%`	`27/29`
`@36:18(...)`	`github.com/wfusion/gofusion/config/candy.go`	`90.0%`	`9/10`
`Use(...)`	`github.com/wfusion/gofusion/config/registry.go`	`83.3%`	`5/6`
`CryptoConf.ToOptionMap(...)`	`github.com/wfusion/gofusion/config/crypto.go`	`83.3%`	`5/6`
`cryptoConf.ToOptions(...)`	`github.com/wfusion/gofusion/config/crypto.go`	`81.8%`	`9/11`
`registry.cryptoConfig(...)`	`github.com/wfusion/gofusion/config/candy.go`	`80.0%`	`8/10`
`loadConfig(...)`	`github.com/wfusion/gofusion/config/loader.go`	`74.4%`	`29/39`
`registry.LoadComponentConfig(...)`	`github.com/wfusion/gofusion/config/registry.go`	`71.4%`	`20/28`
`@452:37(...)`	`github.com/wfusion/gofusion/config/registry.go`	`66.7%`	`6/9`
`registry.checkBusinessConfig(...)`	`github.com/wfusion/gofusion/config/registry.go`	`66.7%`	`2/3`
`parseConstructor(...)`	`github.com/wfusion/gofusion/config/component.go`	`60.0%`	`15/25`
`indexComponent(...)`	`github.com/wfusion/gofusion/config/component.go`	`60.0%`	`3/5`
`checkCryptoConf(...)`	`github.com/wfusion/gofusion/config/crypto.go`	`57.9%`	`11/19`
`registry.addComponent(...)`	`github.com/wfusion/gofusion/config/registry.go`	`52.9%`	`9/17`
`@170:27(...)`	`github.com/wfusion/gofusion/config/component.go`	`0.0%`	`0/8`
`CryptoDecryptFunc(...)`	`github.com/wfusion/gofusion/config/crypto.go`	`0.0%`	`0/7`
`CryptoEncryptFunc(...)`	`github.com/wfusion/gofusion/config/crypto.go`	`0.0%`	`0/5`
`@156:9(...)`	`github.com/wfusion/gofusion/config/crypto.go`	`0.0%`	`0/1`
`Component.Clone(...)`	`github.com/wfusion/gofusion/config/component.go`	`0.0%`	`0/1`
`Debug(...)`	`github.com/wfusion/gofusion/config/registry.go`	`0.0%`	`0/1`
`@166:9(...)`	`github.com/wfusion/gofusion/config/crypto.go`	`0.0%`	`0/1`
`@179:9(...)`	`github.com/wfusion/gofusion/config/crypto.go`	`0.0%`	`0/1`
`@112:9(...)`	`github.com/wfusion/gofusion/config/component.go`	`0.0%`	`0/1`
`CryptoConfigName(...)`	`github.com/wfusion/gofusion/config/crypto.go`	`0.0%`	`0/1`
`WithCore(...)`	`github.com/wfusion/gofusion/config/component.go`	`0.0%`	`0/1`
`@102:9(...)`	`github.com/wfusion/gofusion/config/registry.go`	`0.0%`	`0/1`
`@111:9(...)`	`github.com/wfusion/gofusion/config/crypto.go`	`100.0%`	`0/0`

func registry.initComponents

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

func (p *registry) initComponents(parent context.Context) func() {
        ctx, cancel := context.WithCancel(parent)
        ctxVal := reflect.ValueOf(ctx)
        o1 := reflect.ValueOf(utils.OptionExtender(AppName(p.appName)))
        o2 := reflect.ValueOf(utils.OptionExtender(DI(p.di)))

        baseObject := p.getBaseObject()
        destructors := make([]reflect.Value, 0, len(p.componentList))
        componentNames := make([]string, 0, len(p.componentList))
        hasCallbackComponentNames := make([]string, 0, len(p.componentList))
        for i := 0; i < len(p.componentList); i++ {
                com := p.componentList[i]
                comArgs := reflect.ValueOf(clone.Clone(baseObject.FieldByName(com.Name).Interface()))
                componentNames = append(componentNames, com.Name)
                if out := com.Constructor.Call([]reflect.Value{ctxVal, comArgs, o1, o2}); len(out) > 0 && !out[0].IsNil() {
                        destructors = append(destructors, out[0])
                        hasCallbackComponentNames = append(hasCallbackComponentNames, com.Name)
                }
        }

        /* print summary to stdout */
        pid := syscall.Getpid()
        app := p.AppName()
        log.SetFlags(log.Lshortfile | log.Ldate | log.Lmicroseconds)
        log.Printf("%v [Gofusion] %s initialized total %d components below: %s\n",
                pid, app, len(componentNames), strings.Join(componentNames, ", "))

        once := new(sync.Once)
        return func() {
                once.Do(func() {
                        initLocker.Lock()
                        defer initLocker.Unlock()

                        defer close(p.closeCh)

                        p.initWg.Done()
                        p.initWg.Wait()
                        cancel()
                        for i := len(destructors) - 1; i >= 0; i-- {
                                log.Printf("%v [Gofusion] %s %s exiting...", pid, app, hasCallbackComponentNames[i])
                                destructors[i].Call(nil)
                                log.Printf("%v [Gofusion] %s %s exited", pid, app, hasCallbackComponentNames[i])
                        }

                        p.di.Clear()
                        p.businessConfig = nil
                        p.componentConfigs = nil
                        p.initOnce = new(sync.Once)
                })
        }
}

func @419:11

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

func() {
                        initLocker.Lock()
                        defer initLocker.Unlock()

                        defer close(p.closeCh)

                        p.initWg.Done()
                        p.initWg.Wait()
                        cancel()
                        for i := len(destructors) - 1; i >= 0; i-- {
                                log.Printf("%v [Gofusion] %s %s exiting...", pid, app, hasCallbackComponentNames[i])
                                destructors[i].Call(nil)
                                log.Printf("%v [Gofusion] %s %s exited", pid, app, hasCallbackComponentNames[i])
                        }

                        p.di.Clear()
                        p.businessConfig = nil
                        p.componentConfigs = nil
                        p.initOnce = new(sync.Once)
                }

func registry.initByConfigFile

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

func (p *registry) initByConfigFile(parent context.Context, businessConfig any,
        loadFn loadConfigFunc, opts ...utils.OptionExtender) func() {
        p.loadComponents()
        p.checkBusinessConfig(businessConfig)
        p.initAllConfigByLoadFunc(businessConfig, loadFn, opts...)

        appName := p.AppName()
        registryLock.Lock()
        if _, ok := registryMap[appName]; !ok {
                registryMap[appName] = p
        }
        registryLock.Unlock()

        // decrypt
        CryptoDecryptByTag(p.businessConfig, AppName(p.AppName()))
        CryptoDecryptByTag(p.componentConfigs, AppName(p.AppName()))

        // give back
        reflect.Indirect(reflect.ValueOf(businessConfig)).Set(reflect.ValueOf(p.businessConfig))

        return p.initComponents(parent)
}

func registry.GetAllConfigs

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

func (p *registry) GetAllConfigs() any {
        val := reflect.New(p.makeAllConfigStruct())
        derefVal := reflect.Indirect(val)

        // business configs
        businessConfigsVal := reflect.Indirect(reflect.ValueOf(p.businessConfig))
        numFields := businessConfigsVal.NumField()
        for i := 0; i < numFields; i++ {
                derefVal.Field(i + 1).Set(businessConfigsVal.Field(i))
        }

        // component configs
        derefComponentConfigsVal := derefVal.FieldByName(componentConfigFieldName)
        componentConfigsVal := reflect.Indirect(reflect.ValueOf(p.componentConfigs)).FieldByName(componentConfigFieldName)
        numFields = componentConfigsVal.NumField()
        for i := 0; i < numFields; i++ {
                derefComponentConfigsVal.Field(i).Set(componentConfigsVal.Field(i))
        }
        return clone.Clone(val.Interface())
}

func @112:16

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

func() {
                opt := utils.ApplyOptions[initOption](opts...)
                p.debug = opt.debug
                p.closeCh = make(chan struct{})

                // context
                parent := context.Background()
                if opt.bizCtx != nil {
                        parent = opt.bizCtx
                }

                // load config function
                loadFn := loadConfig
                if opt.customLoadFunc != nil {
                        loadFn = opt.customLoadFunc
                }

                gracefully = p.initByConfigFile(parent, businessConfig, loadFn, opts...)
        }

func cryptoConf.cryptoConfuseKey

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/crypto.go:

func (c *cryptoConf) cryptoConfuseKey(key []byte) (confused []byte) {
        var (
                k1 = make([]byte, len(key))
                k2 = make([]byte, len(key))
                k3 = make([]byte, len(key))
        )
        rndSeed := int64(crc64.Checksum(key, crc64.MakeTable(crc64.ISO)))
        utils.Must(rand.New(rand.NewSource(cipher.RndSeed ^ compress.RndSeed ^ rndSeed)).Read(k1))
        utils.Must(rand.New(rand.NewSource(cipher.RndSeed ^ encode.RndSeed ^ rndSeed)).Read(k2))
        utils.Must(rand.New(rand.NewSource(compress.RndSeed ^ encode.RndSeed ^ rndSeed)).Read(k3))

        confused = make([]byte, len(key))
        utils.Must(rand.New(rand.NewSource(cipher.RndSeed ^ compress.RndSeed ^ encode.RndSeed)).Read(confused))
        for i := 0; i < len(confused); i++ {
                confused[i] ^= k1[i] ^ k2[i] ^ k3[i]
        }
        return
}

func registry.Init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

func (p *registry) Init(businessConfig any, opts ...utils.OptionExtender) (gracefully func()) {
        initLocker.Lock()
        defer initLocker.Unlock()

        p.initWg.Add(1)
        p.initOnce.Do(func() {
                opt := utils.ApplyOptions[initOption](opts...)
                p.debug = opt.debug
                p.closeCh = make(chan struct{})

                // context
                parent := context.Background()
                if opt.bizCtx != nil {
                        parent = opt.bizCtx
                }

                // load config function
                loadFn := loadConfig
                if opt.customLoadFunc != nil {
                        loadFn = opt.customLoadFunc
                }

                gracefully = p.initByConfigFile(parent, businessConfig, loadFn, opts...)
        })
        if gracefully == nil {
                // give back
                reflect.Indirect(reflect.ValueOf(businessConfig)).Set(reflect.ValueOf(p.businessConfig))

                once := new(sync.Once)
                gracefully = func() {
                        once.Do(func() {
                                p.initWg.Done()
                        })
                }
        }
        return
}

func New

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

func New(appName string) Configurable {
        registryLock.Lock()
        defer registryLock.Unlock()
        if reg, ok := registryMap[appName]; ok {
                return reg
        }

        reg := &registry{
                di:       di.NewDI(),
                appName:  appName,
                initOnce: new(sync.Once),
                closeCh:  make(chan struct{}),
        }
        registryMap[appName] = reg
        return reg
}

func registry.initAllConfigByLoadFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

func (p *registry) initAllConfigByLoadFunc(businessConfig any, loadFn loadConfigFunc, opts ...utils.OptionExtender) {
        businessConfigVal := reflect.ValueOf(businessConfig)
        p.businessConfigType = utils.IndirectType(businessConfigVal.Type())

        p.businessConfig = reflect.New(p.businessConfigType).Interface()
        p.componentConfigs = reflect.New(p.makeComponentsConfigStruct()).Interface()
        if loadFn != nil {
                loadFn(p.businessConfig, opts...)
                loadFn(p.componentConfigs, opts...)
        }
}

func registry.makeAllConfigStruct

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

func (p *registry) makeAllConfigStruct() reflect.Type {
        /* AllConfig struct may look like below
        type AllConfig struct {
                XXXBase struct {
                        Debug       bool
                        App         string
                        DB          map[string]*db.Conf
                        Redis       map[string]*redis.Conf
                        Log         *log.Conf
                        ...
                } `yaml:"base" json:"base" toml:"base"`

                BusinessConfigField1
            BusinessConfigField2
                BusinessConfigField3

                ...
        }
        */

        numFields := p.businessConfigType.NumField()
        fieldList := make([]reflect.StructField, 0, numFields+1)
        fieldList = append(fieldList, reflect.StructField{
                Name:      componentConfigFieldName,
                Type:      reflect.StructOf(p.makeComponentsConfigFields()),
                Tag:       `yaml:"base" json:"base" toml:"base"`,
                Anonymous: true,
        })
        for i := 0; i < numFields; i++ {
                fieldList = append(fieldList, p.businessConfigType.Field(i))
        }

        return reflect.StructOf(fieldList)
}

func CryptoConstruct

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/crypto.go:

func CryptoConstruct(ctx context.Context, c CryptoConf, _ ...utils.OptionExtender) func() {
        if c.Config != nil {
                checkCryptoConf("", c.Config)
        }
        for name, cfg := range c.Custom {
                if cfg != nil {
                        checkCryptoConf(name, cfg)
                }
        }

        return func() {

        }
}

func CryptoDecryptByTag

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/crypto.go:

func CryptoDecryptByTag(data any, opts ...utils.OptionExtender) {
        o := utils.ApplyOptions[InitOption](opts...)
        optsMap := Use(o.AppName).(*registry).cryptoConfig().ToOptionMap()
        for _, opts := range optsMap {
                utils.SliceReverse(opts)
        }

        supportedFields := utils.NewSet(reflect.Struct, reflect.Array, reflect.Slice, reflect.Map)
        utils.TraverseValue(data, false, func(field reflect.StructField, value reflect.Value) (end, stepIn bool) {
                if !value.IsValid() || !value.CanInterface() || !value.CanSet() {
                        return
                }

                vk := value.Kind()
                stepIn = supportedFields.Contains(vk) ||
                        (vk == reflect.Ptr && value.Elem().IsValid() && value.Elem().Kind() == reflect.Struct)

                configName, ok := field.Tag.Lookup(cryptoTagKey)
                if !ok {
                        return
                }
                opts, ok := optsMap[configName]
                if !ok {
                        return
                }
                src := cast.ToString(value.Interface())
                if utils.IsStrBlank(src) {
                        return
                }

                dst := utils.Must(encode.From(src).Decode(opts...).ToString())
                value.SetString(dst)
                return
        })
}

func registry.makeComponentsConfigFields

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

func (p *registry) makeComponentsConfigFields() []reflect.StructField {
        fieldList := make([]reflect.StructField, len(p.componentList))
        for i := 0; i < len(p.componentList); i++ {
                component := p.componentList[i]
                fieldList[i] = reflect.StructField{
                        Name: component.Name,
                        Type: component.ConstructorInputType,
                        Tag:  reflect.StructTag(component.Tag),
                }
        }

        return fieldList
}

func @355:26

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

func() {
                // app
                p.AddComponent(ComponentApp, func(context.Context, string, ...utils.OptionExtender) func() { return nil },
                        WithTag("yaml", "app"), WithTag("json", "app"), WithTag("toml", "app"))

                // debug
                p.AddComponent(ComponentDebug, func(context.Context, bool, ...utils.OptionExtender) func() { return nil },
                        WithTag("yaml", "debug"), WithTag("json", "debug"), WithTag("toml", "debug"))

                // crypto
                p.AddComponent(ComponentCrypto, CryptoConstruct,
                        WithTag("yaml", "crypto"), WithTag("json", "crypto"), WithTag("toml", "crypto"))

                for _, item := range getComponents() {
                        p.AddComponent(item.name, item.constructor, item.opt...)
                }

                /* example */
                // registry.AddComponent("ComponentExample", func(context.Context, string) func() { return nil },
                //    WithTag("custom_tag", "val"), WithTag("yaml", "val"))
        }

func registry.AppName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/candy.go:

func (p *registry) AppName() (name string) {
        if p.appName != "" {
                return p.appName
        }
        _ = p.LoadComponentConfig(ComponentApp, &name)
        return
}

func AddComponent

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/component.go:

func AddComponent(name string, constructor any, opts ...ComponentOption) {
        componentLocker.Lock()
        defer componentLocker.Unlock()
        parseConstructor(constructor)
        components = append(components, &componentItem{name, constructor, opts})
}

func registry.Debug

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/candy.go:

func (p *registry) Debug() (debug bool) {
        if p.appName != "" {
                return p.debug
        }
        _ = p.LoadComponentConfig(ComponentDebug, &debug)
        return
}

func getComponents

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/component.go:

func getComponents() []*componentItem {
        componentLocker.RLock()
        defer componentLocker.RUnlock()
        return clone.Clone(components)
}

func registry.makeComponentsConfigStruct

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

func (p *registry) makeComponentsConfigStruct() reflect.Type {
        fieldList := p.makeComponentsConfigFields()
        return reflect.StructOf([]reflect.StructField{
                {
                        Name:      componentConfigFieldName,
                        Type:      reflect.StructOf(fieldList),
                        Tag:       `yaml:"base" json:"base" toml:"base"`,
                        Anonymous: true,
                },
        })
}

func @96:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

96	`func(o *initOption) {`
97	`o.filenames = filenames`
98	`}`

func DI

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/types.go:

func DI(di di.DI) utils.OptionFunc[InitOption] {
        return func(o *InitOption) {
                o.DI = di
        }
}

func @23:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/types.go:

23	`func(o *InitOption) {`
24	`o.AppName = name`
25	`}`

func AppName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/types.go:

func AppName(name string) utils.OptionFunc[InitOption] {
        return func(o *InitOption) {
                o.AppName = name
        }
}

func WithTag

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/component.go:

func WithTag(name, val string) ComponentOption {
        return func(opt *options) {
                opt.TagList = append(opt.TagList, fmt.Sprintf(`%s:"%s"`, name, val))
        }
}

func @29:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/types.go:

29	`func(o *InitOption) {`
30	`o.DI = di`
31	`}`

func registry.DI

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/candy.go:

29	`func (p *registry) DI() di.DI { return p.di }`

func @418:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

func() {
                once.Do(func() {
                        initLocker.Lock()
                        defer initLocker.Unlock()

                        defer close(p.closeCh)

                        p.initWg.Done()
                        p.initWg.Wait()
                        cancel()
                        for i := len(destructors) - 1; i >= 0; i-- {
                                log.Printf("%v [Gofusion] %s %s exiting...", pid, app, hasCallbackComponentNames[i])
                                destructors[i].Call(nil)
                                log.Printf("%v [Gofusion] %s %s exited", pid, app, hasCallbackComponentNames[i])
                        }

                        p.di.Clear()
                        p.businessConfig = nil
                        p.componentConfigs = nil
                        p.initOnce = new(sync.Once)
                })
        }

func registry.getBaseObject

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

289	`func (p *registry) getBaseObject() reflect.Value {`
290	`return reflect.Indirect(reflect.ValueOf(p.componentConfigs)).FieldByName(componentConfigFieldName)`
291	`}`

func @361:34

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

361	`func(context.Context, bool, ...utils.OptionExtender) func() { return nil }`

func registry.loadComponents

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

func (p *registry) loadComponents() {
        p.loadComponentsOnce.Do(func() {
                // app
                p.AddComponent(ComponentApp, func(context.Context, string, ...utils.OptionExtender) func() { return nil },
                        WithTag("yaml", "app"), WithTag("json", "app"), WithTag("toml", "app"))

                // debug
                p.AddComponent(ComponentDebug, func(context.Context, bool, ...utils.OptionExtender) func() { return nil },
                        WithTag("yaml", "debug"), WithTag("json", "debug"), WithTag("toml", "debug"))

                // crypto
                p.AddComponent(ComponentCrypto, CryptoConstruct,
                        WithTag("yaml", "crypto"), WithTag("json", "crypto"), WithTag("toml", "crypto"))

                for _, item := range getComponents() {
                        p.AddComponent(item.name, item.constructor, item.opt...)
                }

                /* example */
                // registry.AddComponent("ComponentExample", func(context.Context, string) func() { return nil },
                //    WithTag("custom_tag", "val"), WithTag("yaml", "val"))
        })
}

func NewDefaultLoader

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/loader.go:

func NewDefaultLoader(files ...string) *loader {
        return &loader{
                files: files,
        }
}

func loader.Unmarshal

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/loader.go:

func (l *loader) Unmarshal(out any) (err error) {
        return configor.New(&configor.Config{
                Environment:        env.GetEnv(),
                ENVPrefix:          "",
                Debug:              false,
                Verbose:            false,
                Silent:             true,
                AutoReload:         true,
                AutoReloadInterval: 0,
                AutoReloadCallback: func(config any) {
                        log.Printf("%v [Gofusion] Config auto reload config successfully => \n%s",
                                syscall.Getpid(), utils.Must(yaml.Marshal(config)))
                },
                ErrorOnUnmatchedKeys: false,
                FS:                   nil,
        }).Load(out, l.files...)
}

func @40:23

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/loader.go:

40	`func(config any) {`
41	`log.Printf("%v [Gofusion] Config auto reload config successfully => \n%s",`
42	`syscall.Getpid(), utils.Must(yaml.Marshal(config)))`
43	`}`

func @136:16

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

func() {
                        once.Do(func() {
                                p.initWg.Done()
                        })
                }

func newOptions

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/component.go:

99	`func newOptions() *options {`
100	`return &options{}`
101	`}`

func @357:32

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

357	`func(context.Context, string, ...utils.OptionExtender) func() { return nil }`

func @105:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/component.go:

105	`func(opt *options) {`
106	opt.TagList = append(opt.TagList, fmt.Sprintf(`%s:"%s"`, name, val))
107	`}`

func Ctx

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

func Ctx(ctx context.Context) utils.OptionFunc[initOption] {
        return func(o *initOption) {
                o.bizCtx = ctx
        }
}

func @84:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

84	`func(o *initOption) {`
85	`o.bizCtx = ctx`
86	`}`

func Loader

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

func Loader(fn func(any, ...utils.OptionExtender)) utils.OptionFunc[initOption] {
        return func(o *initOption) {
                o.customLoadFunc = fn
        }
}

func @90:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

90	`func(o *initOption) {`
91	`o.customLoadFunc = fn`
92	`}`

func Files

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

func Files(filenames []string) utils.OptionFunc[initOption] {
        return func(o *initOption) {
                o.filenames = filenames
        }
}

func @137:12

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

137	`func() {`
138	`p.initWg.Done()`
139	`}`

func init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/loader.go:

55	`func init() {`
56	`flag.StringVar(&customConfigPath, "configPath", "", "config file path")`
57	`}`

func @192:35

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/crypto.go:

func(field reflect.StructField, value reflect.Value) (end, stepIn bool) {
                if !value.IsValid() || !value.CanInterface() || !value.CanSet() {
                        return
                }

                vk := value.Kind()
                stepIn = supportedFields.Contains(vk) ||
                        (vk == reflect.Ptr && value.Elem().IsValid() && value.Elem().Kind() == reflect.Struct)

                configName, ok := field.Tag.Lookup(cryptoTagKey)
                if !ok {
                        return
                }
                opts, ok := optsMap[configName]
                if !ok {
                        return
                }
                src := cast.ToString(value.Interface())
                if utils.IsStrBlank(src) {
                        return
                }

                dst := utils.Must(encode.From(src).Decode(opts...).ToString())
                value.SetString(dst)
                return
        }

func registry.AddComponent

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

func (p *registry) AddComponent(name string, constructor any, opts ...ComponentOption) {
        if name[0] < 'A' || name[0] > 'Z' {
                panic("component name should start with A-Z")
        }
        for idx, com := range p.componentList {
                if com.Name == name {
                        p.componentList = append(p.componentList[:idx], p.componentList[idx+1:]...)
                }
        }
        opt := newOptions()
        for _, fn := range opts {
                fn(opt)
        }

        com := &Component{
                Name:   name,
                isCore: opt.IsCoreComponent,
        }

        hasYamlTag := false
        hasJsonTag := false
        hasTomlTag := false
        for _, tag := range opt.TagList {
                hasYamlTag = strings.HasPrefix(tag, "`yaml:")
                hasJsonTag = strings.HasPrefix(tag, "`json:")
                hasTomlTag = strings.HasPrefix(tag, "`toml:")
        }
        lowerName := strcase.ToSnake(name)
        if name == ComponentI18n {
                lowerName = strings.ToLower(name)
        }
        if !hasYamlTag {
                opt.TagList = append(opt.TagList, fmt.Sprintf(`yaml:"%s"`, lowerName))
        }
        if !hasJsonTag {
                opt.TagList = append(opt.TagList, fmt.Sprintf(`json:"%s"`, lowerName))
        }
        if !hasTomlTag {
                opt.TagList = append(opt.TagList, fmt.Sprintf(`toml:"%s"`, lowerName))
        }
        if len(opt.TagList) > 0 {
                com.Tag = strings.Join(opt.TagList, " ")
        }

        com.Constructor, com.ConstructorInputType = parseConstructor(constructor)

        p.addComponent(com)
}

func @36:18

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/candy.go:

func(c *cryptoConf) {
                if c == nil {
                        return
                }
                c.Algorithm = cipher.ParseAlgorithm(c.AlgorithmString)
                c.Mode = cipher.ParseMode(c.ModeString)
                c.Key = utils.Must(base64.StdEncoding.DecodeString(c.KeyBase64))
                c.IV = utils.Must(base64.StdEncoding.DecodeString(c.IVBase64))

                if utils.IsStrPtrNotBlank(c.CompressAlgorithmString) {
                        c.CompressAlgorithm = compress.ParseAlgorithm(*c.CompressAlgorithmString)
                }
                if utils.IsStrPtrNotBlank(c.OutputAlgorithmString) {
                        c.OutputAlgorithm = encode.ParseAlgorithm(*c.OutputAlgorithmString)
                }
        }

func Use

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

func Use(appName string, opts ...utils.OptionExtender) Configurable {
        registryLock.RLock()
        defer registryLock.RUnlock()
        cfg, ok := registryMap[appName]
        if !ok {
                panic(errors.Errorf("app register config not found: %s", appName))
        }
        return cfg
}

func CryptoConf.ToOptionMap

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/crypto.go:

func (c *CryptoConf) ToOptionMap() (result map[string][]utils.OptionExtender) {
        result = make(map[string][]utils.OptionExtender)
        if c.Config != nil {
                result[""] = c.Config.ToOptions()
        }
        for name, cfg := range c.Custom {
                result[name] = cfg.ToOptions()
        }
        return
}

func cryptoConf.ToOptions

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/crypto.go:

func (c *cryptoConf) ToOptions() (opts []utils.OptionExtender) {
        if !c.Algorithm.IsValid() {
                return nil
        }

        if c.ConfuseKey {
                c.Key = c.cryptoConfuseKey(c.Key)
        }

        opts = make([]utils.OptionExtender, 0, 3)
        opts = append(opts, encode.Cipher(c.Algorithm, c.Mode, c.Key, c.IV))
        if c.CompressAlgorithm.IsValid() {
                opts = append(opts, encode.Compress(c.CompressAlgorithm))
        }
        if c.OutputAlgorithm.IsValid() {
                opts = append(opts, encode.Encode(c.OutputAlgorithm))
        }
        return
}

func registry.cryptoConfig

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/candy.go:

func (p *registry) cryptoConfig() (conf *CryptoConf) {
        conf = new(CryptoConf)
        if err := p.LoadComponentConfig(ComponentCrypto, &conf); err != nil {
                return
        }
        parseCfgFunc := func(c *cryptoConf) {
                if c == nil {
                        return
                }
                c.Algorithm = cipher.ParseAlgorithm(c.AlgorithmString)
                c.Mode = cipher.ParseMode(c.ModeString)
                c.Key = utils.Must(base64.StdEncoding.DecodeString(c.KeyBase64))
                c.IV = utils.Must(base64.StdEncoding.DecodeString(c.IVBase64))

                if utils.IsStrPtrNotBlank(c.CompressAlgorithmString) {
                        c.CompressAlgorithm = compress.ParseAlgorithm(*c.CompressAlgorithmString)
                }
                if utils.IsStrPtrNotBlank(c.OutputAlgorithmString) {
                        c.OutputAlgorithm = encode.ParseAlgorithm(*c.OutputAlgorithmString)
                }
        }

        if conf != nil {
                parseCfgFunc(conf.Config)
                conf.Custom = make(map[string]*cryptoConf)
                for _, c := range conf.Custom {
                        parseCfgFunc(c)
                }
        }

        return
}

func loadConfig

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/loader.go:

func loadConfig(out any, opts ...utils.OptionExtender) {
        if !flag.Parsed() {
                flag.Parse()
        }

        opt := utils.ApplyOptions[initOption](opts...)

        files := make([]string, 0, 2)
        switch {
        case utils.IsStrNotBlank(customConfigPath):
                files = append(files, filepath.Clean(customConfigPath))
        case len(opt.filenames) > 0:
                files = append(files, opt.filenames...)
        default:
                defaultPathPrefix := filepath.Join(env.WorkDir, "configs", "app.")
                defaultLocal1PathPrefix := filepath.Join(env.WorkDir, "configs", "app.local.")
                defaultLocal2PathPrefix := filepath.Join(env.WorkDir, "configs", "app_local.")
                defaultLocal3PathPrefix := filepath.Join(env.WorkDir, "configs", "app-local.")
                extensions := []string{"yaml", "yml", "json", "toml"}
                for _, ext := range extensions {
                        localFilename := defaultLocal1PathPrefix + ext
                        if _, err := os.Stat(localFilename); err == nil {
                                files = append(files, localFilename)
                                continue
                        }
                        localFilename = defaultLocal2PathPrefix + ext
                        if _, err := os.Stat(localFilename); err == nil {
                                files = append(files, localFilename)
                                continue
                        }
                        localFilename = defaultLocal3PathPrefix + ext
                        if _, err := os.Stat(localFilename); err == nil {
                                files = append(files, localFilename)
                                continue
                        }
                }
                for _, ext := range extensions {
                        defaultFilename := defaultPathPrefix + ext
                        if _, err := os.Stat(defaultFilename); err == nil {
                                files = append(files, defaultFilename)
                        }
                }
        }

        // check if configure file exists first, to avoid auto reload a nonexistent file
        existFiles := make([]string, 0, len(files))
        for _, name := range files {
                if _, err := os.Stat(name); err == nil {
                        existFiles = append(existFiles, name)
                }
        }

        if profile != "" {
                if err := configor.New(&configor.Config{Environment: profile}).Load(out, existFiles...); err != nil {
                        panic(errors.Errorf("parse config file of config env %s error: %v", profile, err))
                }
                return
        }

        if err := NewDefaultLoader(files...).Unmarshal(out); err != nil {
                panic(errors.Errorf("parse config file error! %s", err))
        }
}

func registry.LoadComponentConfig

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

func (p *registry) LoadComponentConfig(name string, componentConfig any) (err error) {
        val := reflect.ValueOf(componentConfig)
        typ := val.Type()
        if typ.Kind() != reflect.Ptr {
                return errors.New("componentConfig should be pointer")
        }

        var found bool
        for _, com := range p.componentList {
                if com.Name == name {
                        found = true
                        break
                }
        }
        if !found {
                return errors.Errorf("no such component [%s]", name)
        }

        // load config
        if p.componentConfigs == nil {
                return
        }
        componentConfigsValue := utils.IndirectValue(reflect.ValueOf(clone.Clone(p.componentConfigs)))
        if !componentConfigsValue.IsValid() {
                return errors.Errorf("component configs not initialize now [%s]", name)
        }
        componentConfigValue := componentConfigsValue.FieldByName(componentConfigFieldName).FieldByName(name)

        if componentConfigValue.Type().Kind() == reflect.Ptr {
                if componentConfigValue.IsNil() {
                        return
                }
                componentConfigValue = componentConfigValue.Elem()
        }
        if componentConfigValue.Type() == typ.Elem() || componentConfigValue.Type().ConvertibleTo(typ.Elem()) {
                val.Elem().Set(reflect.ValueOf(clone.Clone(componentConfigValue.Convert(typ.Elem()).Interface())))
                return
        }

        decoder, err := mapstructure.NewDecoder(&mapstructure.DecoderConfig{
                Metadata:         nil,
                Result:           componentConfig,
                TagName:          "yaml",
                WeaklyTypedInput: true,
        })
        if err != nil {
                return
        }
        return decoder.Decode(componentConfigValue.Interface())
}

func @452:37

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

func(i, j int) bool {
                        // core component would not be sorted
                        if p.componentList[i].isCore || p.componentList[j].isCore {
                                return false
                        }

                        orderA := indexComponent(p.componentList[i].Name)
                        if orderA == -1 {
                                return false
                        }
                        orderB := indexComponent(p.componentList[j].Name)
                        if orderB == -1 {
                                return true
                        }

                        return orderA < orderB
                }

func registry.checkBusinessConfig

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

func (p *registry) checkBusinessConfig(businessConfig any) {
        typ := reflect.TypeOf(businessConfig)
        if typ.Kind() != reflect.Ptr || typ.Elem().Kind() != reflect.Ptr {
                panic(errors.New("businessConfig should be a **struct"))
        }
}

func parseConstructor

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/component.go:

func parseConstructor(fn any) (fnVal reflect.Value, input reflect.Type) {
        fnVal = reflect.ValueOf(fn)
        typ := reflect.TypeOf(fn)
        if typ.Kind() != reflect.Func {
                panic(errors.New("component constructor should be a function"))
        }

        // check output
        if typ.NumOut() != 1 {
                panic(errors.New("component constructor should return one finalizer function"))
        }
        retTyp := typ.Out(0)
        if retTyp.Kind() != reflect.Func {
                panic(errors.New("component constructor should return one finalizer function"))
        }
        if retTyp.NumIn() != 0 {
                panic(errors.New("component constructor should return one finalizer function looks like func()"))
        }

        // check input
        fnType := fnVal.Type()
        if n := fnType.NumIn(); n != 1 && (!fnType.IsVariadic() && n != 3) {
                panic(errors.New("component constructor should receive input looks like " +
                        "func(context.Context), func(context.Context, *serializableConf, ...utils.OptionExtender)"))
        }
        if fnType.In(0) != constant.ContextType {
                panic(errors.New("component constructor should receive context.Context as first input " +
                        "looks like func(context.Context), func(context.Context, *serializableConf, ...utils.OptionExtender)"))
        }

        // wrapper
        switch typ.NumIn() {
        case 1:
                input = reflect.TypeOf(int(0))
                fnVal = reflect.ValueOf(func(ctx context.Context, mock int, _ ...utils.OptionExtender) func() {
                        out := reflect.ValueOf(fn).Call([]reflect.Value{reflect.ValueOf(ctx)})
                        if retfn := out[0]; retfn.IsNil() {
                                return nil
                        } else if obj := retfn.Interface(); obj == nil {
                                return nil
                        } else if fn, ok := obj.(func()); !ok {
                                return nil
                        } else {
                                return fn
                        }
                })
        case 3:
                input = typ.In(1)
                argsType := typ.In(2)
                if argsType.Kind() != reflect.Slice ||
                        argsType.Elem() != reflect.TypeOf((*utils.OptionExtender)(nil)).Elem() {
                        panic(errors.New("component constructor only receive utils.OptionExtender variadic input"))
                }
        default:
                panic(errors.New("component constructor should receive one or three inputs looks like " +
                        "func(context.Context), func(context.Context, *serializableConf, ...utils.OptionExtender)"))
        }
        return
}

func indexComponent

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/component.go:

func indexComponent(name string) (idx int) {
        for idx = 0; idx < len(componentOrder); idx++ {
                if componentOrder[idx] == name {
                        return
                }
        }
        idx = -1
        return
}

func checkCryptoConf

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/crypto.go:

func checkCryptoConf(name string, c *cryptoConf) {
        // cipher
        if c.Algorithm = cipher.ParseAlgorithm(c.AlgorithmString); !c.Algorithm.IsValid() {
                panic(errors.Errorf("unknown config %s algorithm: %s", name, c.AlgorithmString))
        }
        c.Mode = cipher.ParseMode(c.ModeString)
        if !c.Mode.IsValid() {
                panic(errors.Errorf("unknown config %s mode: %s", name, c.ModeString))
        }
        if utils.IsStrBlank(c.KeyBase64) {
                panic(errors.Errorf("%s not found crypto key", name))
        }
        c.Key = utils.Must(base64.StdEncoding.DecodeString(c.KeyBase64))
        if c.Mode.NeedIV() && utils.IsStrBlank(c.IVBase64) {
                panic(errors.Errorf("%s not found crypto iv", name))
        }
        c.IV = utils.Must(base64.StdEncoding.DecodeString(c.IVBase64))

        // compress
        if utils.IsStrPtrNotBlank(c.CompressAlgorithmString) {
                c.CompressAlgorithm = compress.ParseAlgorithm(*c.CompressAlgorithmString)
                if !c.CompressAlgorithm.IsValid() {
                        panic(errors.Errorf("unknown config %s compress algorithm: %s", name, *c.CompressAlgorithmString))
                }
        }

        // output
        if utils.IsStrPtrNotBlank(c.OutputAlgorithmString) {
                c.OutputAlgorithm = encode.ParseAlgorithm(*c.OutputAlgorithmString)
                if !c.OutputAlgorithm.IsValid() {
                        panic(errors.Errorf("unknown config %s output algorithm: %s", name, *c.OutputAlgorithmString))
                }
        }
}

func registry.addComponent

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

func (p *registry) addComponent(com *Component) {
        firstNonCoreComIndex := -1
        for i, cp := range p.componentList {
                if !cp.isCore {
                        firstNonCoreComIndex = i
                        break
                }
        }
        if !com.isCore || firstNonCoreComIndex == -1 {
                p.componentList = append(p.componentList, com)
                sort.SliceStable(p.componentList, func(i, j int) bool {
                        // core component would not be sorted
                        if p.componentList[i].isCore || p.componentList[j].isCore {
                                return false
                        }

                        orderA := indexComponent(p.componentList[i].Name)
                        if orderA == -1 {
                                return false
                        }
                        orderB := indexComponent(p.componentList[j].Name)
                        if orderB == -1 {
                                return true
                        }

                        return orderA < orderB
                })

                return
        }
        list := make([]*Component, len(p.componentList)+1)
        for i := range list {
                if i < firstNonCoreComIndex {
                        list[i] = p.componentList[i]
                } else if i == firstNonCoreComIndex {
                        list[i] = com
                } else {
                        list[i] = p.componentList[i-1]
                }
        }

        p.componentList = list
}

func @170:27

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/component.go:

func(ctx context.Context, mock int, _ ...utils.OptionExtender) func() {
                        out := reflect.ValueOf(fn).Call([]reflect.Value{reflect.ValueOf(ctx)})
                        if retfn := out[0]; retfn.IsNil() {
                                return nil
                        } else if obj := retfn.Interface(); obj == nil {
                                return nil
                        } else if fn, ok := obj.(func()); !ok {
                                return nil
                        } else {
                                return fn
                        }
                }

func CryptoDecryptFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/crypto.go:

func CryptoDecryptFunc(opts ...utils.OptionExtender) func(src string) (dst string) {
        o := utils.ApplyOptions[InitOption](opts...)
        opt := utils.ApplyOptions[cryptoConfigOption](opts...)
        optsMap := Use(o.AppName).(*registry).cryptoConfig().ToOptionMap()
        for _, opts := range optsMap {
                utils.SliceReverse(opts)
        }
        opts = optsMap[opt.name]
        return func(src string) (dst string) {
                return utils.Must(encode.From(src).Decode(opts...).ToString())
        }
}

func CryptoEncryptFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/crypto.go:

func CryptoEncryptFunc(opts ...utils.OptionExtender) func(src string) (dst string) {
        o := utils.ApplyOptions[InitOption](opts...)
        opt := utils.ApplyOptions[cryptoConfigOption](opts...)
        optsMap := Use(o.AppName).(*registry).cryptoConfig().ToOptionMap()
        opts = optsMap[opt.name]
        return func(src string) (dst string) {
                return utils.Must(encode.From(src).Encode(opts...).ToString())
        }
}

func @156:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/crypto.go:

156	`func(o *cryptoConfigOption) {`
157	`o.name = name`
158	`}`

func Component.Clone

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/component.go:

func (c *Component) Clone() (r *Component) {
        return &Component{
                Name:                 c.Name,
                Tag:                  c.Tag,
                Constructor:          c.Constructor,
                ConstructorInputType: c.ConstructorInputType,
                isCore:               c.isCore,
        }
}

func Debug

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

func Debug() utils.OptionFunc[initOption] {
        return func(o *initOption) {
                o.debug = true
        }
}

func @166:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/crypto.go:

166	`func(src string) (dst string) {`
167	`return utils.Must(encode.From(src).Encode(opts...).ToString())`
168	`}`

func @179:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/crypto.go:

179	`func(src string) (dst string) {`
180	`return utils.Must(encode.From(src).Decode(opts...).ToString())`
181	`}`

func @112:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/component.go:

112	`func(opt *options) {`
113	`opt.IsCoreComponent = true`
114	`}`

func CryptoConfigName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/crypto.go:

func CryptoConfigName(name string) utils.OptionFunc[cryptoConfigOption] {
        return func(o *cryptoConfigOption) {
                o.name = name
        }
}

func WithCore

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/component.go:

func WithCore() ComponentOption {
        return func(opt *options) {
                opt.IsCoreComponent = true
        }
}

func @102:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/registry.go:

102	`func(o *initOption) {`
103	`o.debug = true`
104	`}`

func @111:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/config/crypto.go:

111	`func() {`
112
113	`}`

Package Overview: github.com/wfusion/gofusion/context 75.0%

Please select a function to see what's left for testing.

`_context.Marshal(...)`	`github.com/wfusion/gofusion/context/context.go`	`100.0%`	`6/6`
`@182:9(...)`	`github.com/wfusion/gofusion/context/context.go`	`100.0%`	`2/2`
`@146:14(...)`	`github.com/wfusion/gofusion/context/context.go`	`100.0%`	`1/1`
`SetTraceID(...)`	`github.com/wfusion/gofusion/context/candy.go`	`100.0%`	`1/1`
`GetLangs(...)`	`github.com/wfusion/gofusion/context/candy.go`	`100.0%`	`1/1`
`Watermill(...)`	`github.com/wfusion/gofusion/context/context.go`	`100.0%`	`1/1`
`GetCronTaskID(...)`	`github.com/wfusion/gofusion/context/candy.go`	`100.0%`	`1/1`
`@189:9(...)`	`github.com/wfusion/gofusion/context/context.go`	`100.0%`	`1/1`
`GetCronTaskName(...)`	`github.com/wfusion/gofusion/context/candy.go`	`100.0%`	`1/1`
`SetCronTaskName(...)`	`github.com/wfusion/gofusion/context/candy.go`	`100.0%`	`1/1`
`Gin(...)`	`github.com/wfusion/gofusion/context/context.go`	`100.0%`	`1/1`
`GetTraceID(...)`	`github.com/wfusion/gofusion/context/candy.go`	`100.0%`	`1/1`
`GetUserID(...)`	`github.com/wfusion/gofusion/context/candy.go`	`100.0%`	`1/1`
`@195:9(...)`	`github.com/wfusion/gofusion/context/context.go`	`100.0%`	`1/1`
`Context(...)`	`github.com/wfusion/gofusion/context/context.go`	`100.0%`	`1/1`
`newOption.messageUnmarshal(...)`	`github.com/wfusion/gofusion/context/context.go`	`75.0%`	`18/24`
`Flatten(...)`	`github.com/wfusion/gofusion/context/context.go`	`73.3%`	`11/15`
`New(...)`	`github.com/wfusion/gofusion/context/context.go`	`71.4%`	`5/7`
`_context.unmarshal(...)`	`github.com/wfusion/gofusion/context/context.go`	`70.6%`	`12/17`
`newOption.ginUnmarshal(...)`	`github.com/wfusion/gofusion/context/context.go`	`69.2%`	`9/13`
`WatermillMetadata(...)`	`github.com/wfusion/gofusion/context/context.go`	`68.8%`	`11/16`
`SetCronTaskID(...)`	`github.com/wfusion/gofusion/context/candy.go`	`0.0%`	`0/1`
`SetLangs(...)`	`github.com/wfusion/gofusion/context/candy.go`	`0.0%`	`0/1`
`SetUserID(...)`	`github.com/wfusion/gofusion/context/candy.go`	`0.0%`	`0/1`

func _context.Marshal

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/context/context.go:

func (c *_context) Marshal() (b []byte) {
        bs, cb := utils.BytesBufferPool.Get(nil)
        defer cb()
        utils.MustSuccess(gob.NewEncoder(bs).Encode(c))

        b = make([]byte, bs.Len())
        copy(b, bs.Bytes())
        return
}

func @182:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/context/context.go:

182	`func(o *newOption) {`
183	`o.c = new(_context)`
184	`utils.MustSuccess(utils.Unmarshal(c, o.c, ""))`
185	`}`

func @146:14

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/context/context.go:

146	`func(k string) string { return o.m[k] }`

func SetTraceID

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/context/candy.go:

21	`func SetTraceID(ctx context.Context, val string) context.Context {`
22	`return utils.SetCtxAny(ctx, KeyTraceID, val)`
23	`}`

func GetLangs

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/context/candy.go:

25	`func GetLangs(ctx context.Context, args ...[]string) (langs []string) {`
26	`return utils.GetCtxAny(ctx, KeyLangs, args...)`
27	`}`

func Watermill

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/context/context.go:

func Watermill(m message.Metadata) utils.OptionFunc[newOption] {
        return func(o *newOption) {
                o.m = m
        }
}

func GetCronTaskID

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/context/candy.go:

33	`func GetCronTaskID(ctx context.Context, args ...string) (userID string) {`
34	`return utils.GetCtxAny(ctx, KeyCronTaskID, args...)`
35	`}`

func @189:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/context/context.go:

189	`func(o *newOption) {`
190	`o.g = c`
191	`}`

func GetCronTaskName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/context/candy.go:

41	`func GetCronTaskName(ctx context.Context, args ...string) (userID string) {`
42	`return utils.GetCtxAny(ctx, KeyCronTaskName, args...)`
43	`}`

func SetCronTaskName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/context/candy.go:

45	`func SetCronTaskName(ctx context.Context, val string) context.Context {`
46	`return utils.SetCtxAny(ctx, KeyCronTaskName, val)`
47	`}`

func Gin

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/context/context.go:

func Gin(c *gin.Context) utils.OptionFunc[newOption] {
        return func(o *newOption) {
                o.g = c
        }
}

func GetTraceID

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/context/candy.go:

17	`func GetTraceID(ctx context.Context, args ...string) (traceID string) {`
18	`return utils.GetCtxAny(ctx, KeyTraceID, args...)`
19	`}`

func GetUserID

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/context/candy.go:

9	`func GetUserID(ctx context.Context, args ...string) (userID string) {`
10	`return utils.GetCtxAny(ctx, KeyUserID, args...)`
11	`}`

func @195:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/context/context.go:

195	`func(o *newOption) {`
196	`o.m = m`
197	`}`

func Context

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/context/context.go:

func Context(c []byte) utils.OptionFunc[newOption] {
        return func(o *newOption) {
                o.c = new(_context)
                utils.MustSuccess(utils.Unmarshal(c, o.c, ""))
        }
}

func newOption.messageUnmarshal

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/context/context.go:

func (o *newOption) messageUnmarshal() (ctx context.Context) {
        ctx = context.Background()
        mapGetFn := func(k string) string { return o.m[k] }
        if userID := utils.LookupByFuzzyKeyword[string](mapGetFn, "user_id"); utils.IsStrNotBlank(userID) {
                ctx = SetUserID(ctx, userID)
        }
        if traceID := utils.LookupByFuzzyKeyword[string](mapGetFn, "trace_id"); utils.IsStrNotBlank(traceID) {
                ctx = SetTraceID(ctx, traceID)
        }
        if langstr := utils.LookupByFuzzyKeyword[string](mapGetFn, "langs"); utils.IsStrNotBlank(langstr) {
                var langs []string
                _ = json.Unmarshal([]byte(langstr), &langs)
                ctx = SetLangs(ctx, langs)
        }
        if taskID := utils.LookupByFuzzyKeyword[string](mapGetFn, "cron_task_id"); utils.IsStrNotBlank(taskID) {
                ctx = SetCronTaskID(ctx, taskID)
        }
        if name := utils.LookupByFuzzyKeyword[string](mapGetFn, "cron_task_name"); utils.IsStrNotBlank(name) {
                ctx = SetCronTaskName(ctx, name)
        }
        if messageUUID := o.m[watermill.ContextKeyMessageUUID]; utils.IsStrNotBlank(messageUUID) {
                ctx = utils.SetCtxAny(ctx, watermill.ContextKeyMessageUUID, messageUUID)
        }
        if messageRawID := o.m[watermill.ContextKeyRawMessageID]; utils.IsStrNotBlank(messageRawID) {
                ctx = utils.SetCtxAny(ctx, watermill.ContextKeyRawMessageID, messageRawID)
        }

        deadline := utils.LookupByFuzzyKeyword[string](mapGetFn, "deadline")
        deadlineLoc := utils.LookupByFuzzyKeyword[string](mapGetFn, "deadline_location")
        if utils.IsStrNotBlank(deadline) {
                location := utils.Must(time.LoadLocation(deadlineLoc))
                // FIXME: it may result context leak issue
                ctx, _ = context.WithDeadline(ctx, utils.Must(time.ParseInLocation(time.RFC3339Nano, deadline, location)))
        }
        return
}

func Flatten

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/context/context.go:

func Flatten(ctx context.Context) (c *_context) {
        c = new(_context)
        if langs := GetLangs(ctx); langs != nil {
                c.Langs = langs
        }
        if userID := GetUserID(ctx); utils.IsStrNotBlank(userID) {
                c.UserID = utils.AnyPtr(userID)
        }
        if traceID := GetTraceID(ctx); utils.IsStrNotBlank(traceID) {
                c.TraceID = utils.AnyPtr(traceID)
        }
        if taskID := GetCronTaskID(ctx); utils.IsStrNotBlank(taskID) {
                c.CronTaskID = utils.AnyPtr(taskID)
        }
        if taskName := GetCronTaskName(ctx); utils.IsStrNotBlank(taskName) {
                c.CronTaskName = utils.AnyPtr(taskName)
        }
        if deadline, ok := ctx.Deadline(); ok {
                c.Deadline = utils.AnyPtr(deadline.Format(time.RFC3339Nano))
                c.DeadlineLocation = utils.AnyPtr(deadline.Location().String())
        }
        return
}

func New

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/context/context.go:

func New(opts ...utils.OptionExtender) (ctx context.Context) {
        o := utils.ApplyOptions[newOption](opts...)

        // alternative
        switch {
        case o.g != nil:
                return o.ginUnmarshal()
        case o.c != nil:
                return o.c.unmarshal()
        case o.m != nil:
                return o.messageUnmarshal()
        default:
                panic(ErrUnknownInstantiationMethod)
        }

        return
}

func _context.unmarshal

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/context/context.go:

func (c *_context) unmarshal() (ctx context.Context) {
        ctx = context.Background()
        if c == nil {
                return
        }

        if c.Langs != nil {
                ctx = SetLangs(ctx, c.Langs)
        }
        if c.UserID != nil {
                ctx = SetUserID(ctx, *c.UserID)
        }
        if c.TraceID != nil {
                ctx = SetTraceID(ctx, *c.TraceID)
        }
        if c.CronTaskID != nil {
                ctx = SetCronTaskID(ctx, *c.CronTaskID)
        }
        if c.CronTaskName != nil {
                ctx = SetCronTaskName(ctx, *c.CronTaskName)
        }
        if c.Deadline != nil {
                location := utils.Must(time.LoadLocation(*c.DeadlineLocation))
                // FIXME: it may result context leak issue
                ctx, _ = context.WithDeadline(ctx, utils.Must(time.ParseInLocation(time.RFC3339Nano, *c.Deadline, location)))
        }

        return
}

func newOption.ginUnmarshal

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/context/context.go:

func (o *newOption) ginUnmarshal() (ctx context.Context) {
        ctx = context.Background()
        if userID := o.g.GetString(KeyUserID); utils.IsStrNotBlank(userID) {
                ctx = SetUserID(ctx, userID)
        }
        if traceID := o.g.GetString(KeyTraceID); utils.IsStrNotBlank(traceID) {
                ctx = SetTraceID(ctx, traceID)
        }
        langs := o.g.Request.Header.Values("Accept-Language")
        if lang := o.g.GetString("lang"); utils.IsStrNotBlank(lang) {
                langs = append(langs, lang)
        }
        if lang := o.g.GetString(KeyLangs); utils.IsStrNotBlank(lang) {
                langs = append(langs, lang)
        }
        if len(langs) > 0 {
                ctx = SetLangs(ctx, langs)
        }
        return
}

func WatermillMetadata

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/context/context.go:

func WatermillMetadata(ctx context.Context) (metadata message.Metadata) {
        metadata = make(message.Metadata)
        if langs := GetLangs(ctx); langs != nil {
                marshaled, _ := json.Marshal(langs)
                metadata["langs"] = string(marshaled)
        }
        if userID := GetUserID(ctx); utils.IsStrNotBlank(userID) {
                metadata["user_id"] = userID
        }
        if traceID := GetTraceID(ctx); utils.IsStrNotBlank(traceID) {
                metadata["trace_id"] = traceID
        }
        if taskID := GetCronTaskID(ctx); utils.IsStrNotBlank(taskID) {
                metadata["cron_task_id"] = taskID
        }
        if taskName := GetCronTaskName(ctx); utils.IsStrNotBlank(taskName) {
                metadata["cron_task_name"] = taskName
        }
        if deadline, ok := ctx.Deadline(); ok {
                metadata["deadline"] = deadline.Format(time.RFC3339Nano)
                metadata["deadline_location"] = deadline.Location().String()
        }
        return
}

func SetCronTaskID

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/context/candy.go:

37	`func SetCronTaskID(ctx context.Context, val string) context.Context {`
38	`return utils.SetCtxAny(ctx, KeyCronTaskID, val)`
39	`}`

func SetLangs

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/context/candy.go:

29	`func SetLangs(ctx context.Context, val []string) context.Context {`
30	`return utils.SetCtxAny(ctx, KeyLangs, val)`
31	`}`

func SetUserID

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/context/candy.go:

13	`func SetUserID(ctx context.Context, val string) context.Context {`
14	`return utils.SetCtxAny(ctx, KeyUserID, val)`
15	`}`

Package Overview: github.com/wfusion/gofusion/cron 76.8%

Please select a function to see what's left for testing.

`@277:9(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`100.0%`	`13/13`
`asynqRouter.adaptAsynqHandlerFunc(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`100.0%`	`13/13`
`asynqRouter.initServer(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`100.0%`	`10/10`
`@208:26(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`100.0%`	`9/9`
`Construct(...)`	`github.com/wfusion/gofusion/cron/construct.go`	`100.0%`	`7/7`
`asynqRouter.shutdown(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`100.0%`	`7/7`
`@377:27(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`100.0%`	`7/7`
`@344:8(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`100.0%`	`2/2`
`asynqRouter.initTrigger(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`100.0%`	`2/2`
`asynqRouter.preEnqueueFunc(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`100.0%`	`1/1`
`asynqWrapper.MakeRedisClient(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`100.0%`	`1/1`
`asynqRouter.newTask(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`100.0%`	`1/1`
`asynqRouter.unformatTaskName(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`100.0%`	`1/1`
`task.Name(...)`	`github.com/wfusion/gofusion/cron/types.go`	`100.0%`	`1/1`
`asynqRouter.postEnqueueFunc(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`100.0%`	`1/1`
`asynqRouter.formatTaskName(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`100.0%`	`1/1`
`asynqRouter.formatLockKey(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`100.0%`	`1/1`
`init(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`100.0%`	`1/1`
`asynqRouter.gatewayMiddleware(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`100.0%`	`1/1`
`AppName(...)`	`github.com/wfusion/gofusion/cron/construct.go`	`100.0%`	`1/1`
`asynqRouter.format(...)`	`github.com/wfusion/gofusion/cron/log.go`	`100.0%`	`1/1`
`asynqRouter.defaultQueue(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`100.0%`	`1/1`
`@89:9(...)`	`github.com/wfusion/gofusion/cron/construct.go`	`100.0%`	`1/1`
`@404:10(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`100.0%`	`1/1`
`@409:10(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`100.0%`	`1/1`
`init(...)`	`github.com/wfusion/gofusion/cron/construct.go`	`100.0%`	`1/1`
`@33:9(...)`	`github.com/wfusion/gofusion/cron/construct.go`	`90.9%`	`10/11`
`@302:9(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`90.9%`	`10/11`
`addInstance(...)`	`github.com/wfusion/gofusion/cron/construct.go`	`86.7%`	`13/15`
`asynqRouter.info(...)`	`github.com/wfusion/gofusion/cron/log.go`	`85.7%`	`6/7`
`asynqRouter.debug(...)`	`github.com/wfusion/gofusion/cron/log.go`	`85.7%`	`6/7`
`asynqWrapper.getTaskExecuteInterval(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`85.7%`	`6/7`
`asynqRouter.warn(...)`	`github.com/wfusion/gofusion/cron/log.go`	`85.7%`	`6/7`
`asynqWrapper.GetConfigs(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`84.6%`	`11/13`
`asynqRouter.releaseCronTaskLock(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`83.9%`	`26/31`
`Use(...)`	`github.com/wfusion/gofusion/cron/construct.go`	`80.0%`	`8/10`
`asynqRouter.Start(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`80.0%`	`8/10`
`newAsynq(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`78.8%`	`26/33`
`@429:9(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`75.0%`	`9/12`
`asynqWrapper.getConfigs(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`54.8%`	`17/31`
`asynqRouter.Handle(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`50.0%`	`2/4`
`asynqRouter.Serve(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`0.0%`	`0/12`
`@246:40(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`0.0%`	`0/4`
`@391:9(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`0.0%`	`0/2`
`@256:20(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`0.0%`	`0/2`
`asynqRouter.Use(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`0.0%`	`0/2`
`@451:9(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`0.0%`	`0/1`
`@78:4(...)`	`github.com/wfusion/gofusion/cron/construct.go`	`0.0%`	`0/1`
`asynqRouter.newAsynqTask(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`0.0%`	`0/1`
`asynqRouter.adaptRouterHandlerFunc(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`0.0%`	`0/1`
`asynqRouter.adaptMiddleware(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`0.0%`	`0/1`
`task.ID(...)`	`github.com/wfusion/gofusion/cron/types.go`	`0.0%`	`0/1`
`@243:19(...)`	`github.com/wfusion/gofusion/cron/asynq.go`	`0.0%`	`0/1`
`task.Payload(...)`	`github.com/wfusion/gofusion/cron/types.go`	`0.0%`	`0/1`
`task.RawMessage(...)`	`github.com/wfusion/gofusion/cron/types.go`	`0.0%`	`0/1`

func @277:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

func(task *asynq.Task, opts []asynq.Option) (err error) {
                // when locker is disabled, we cannot determine which message should be discarded
                if a.locker == nil {
                        return
                }

                taskName := a.unformatTaskName(task.Type())
                lockKey := a.formatLockKey(taskName)
                if err = a.locker.Lock(ctx, lockKey, lock.Expire(tolerantOfTimeNotSync), lock.ReentrantKey(a.id)); err == nil {
                        a.info(ctx, "pre enqueue task %s success", taskName)
                        return
                }

                err = utils.ErrIgnore(err, lock.ErrTimeout, lock.ErrContextDone)
                if err == nil {
                        a.debug(ctx, "pre enqueue discard task %s", taskName)
                        return errDiscardMessage
                }

                a.warn(ctx, "pre enqueue task %s failed: %s", taskName, err)
                return
        }

func asynqRouter.adaptAsynqHandlerFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

func (a *asynqRouter) adaptAsynqHandlerFunc(h any) asynq.HandlerFunc {
        if fn, ok := h.(routerHandleFunc); ok {
                return func(ctx context.Context, raw *asynq.Task) (err error) {
                        return fn(ctx, a.newTask(raw))
                }
        }
        if fn, ok := h.(func(ctx context.Context, task Task) (err error)); ok {
                return func(ctx context.Context, raw *asynq.Task) (err error) {
                        return fn(ctx, a.newTask(raw))
                }
        }

        var (
                hasArg          bool
                argType         reflect.Type
                argTypePtrDepth int
        )
        if reflect.TypeOf(h).NumIn() > 1 {
                argType = reflect.TypeOf(h).In(1)
                for argType.Kind() == reflect.Ptr {
                        argType = argType.Elem()
                        argTypePtrDepth++
                }
                hasArg = true
        }

        fn := utils.WrapFunc1[error](h)
        return func(ctx context.Context, raw *asynq.Task) (err error) {
                if !hasArg {
                        return fn(ctx)
                }
                arg := reflect.New(argType)
                payload := raw.Payload()
                if len(payload) == 0 {
                        payload = []byte("null")
                }
                if err = json.Unmarshal(payload, arg.Interface()); err != nil {
                        return
                }
                arg = arg.Elem()
                for i := 0; i < argTypePtrDepth; i++ {
                        arg = arg.Addr()
                }

                return fn(ctx, arg.Interface())
        }
}

func asynqRouter.initServer

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

func (a *asynqRouter) initServer(ctx context.Context, wrapper *asynqWrapper, logLevel asynq.LogLevel) {
        a.ServeMux = asynq.NewServeMux()
        for pattern, taskCfg := range a.c.Tasks {
                if utils.IsStrBlank(taskCfg.Callback) {
                        continue
                }
                handler := *(*routerHandleFunc)(inspect.FuncOf(taskCfg.Callback))
                a.ServeMux.Handle(a.formatTaskName(pattern), a.adaptAsynqHandlerFunc(handler))
        }

        asynqCfg := asynq.Config{
                Concurrency:    a.c.ServerConcurrency,
                BaseContext:    context.Background,
                RetryDelayFunc: asynq.DefaultRetryDelayFunc,
                IsFailure:      func(err error) bool { return !errors.Is(err, errDiscardMessage) },
                Queues:         nil,
                StrictPriority: false,
                ErrorHandler: asynq.ErrorHandlerFunc(func(ctx context.Context, task *asynq.Task, err error) {
                        taskName := "unknown"
                        if task != nil {
                                taskName = a.unformatTaskName(task.Type())
                        }
                        a.info(ctx, "handle task %s message error %s", taskName, err)
                }),
                Logger:          a.logger,
                LogLevel:        logLevel,
                ShutdownTimeout: 8 * time.Second,
                HealthCheckFunc: func(err error) {
                        if err != nil {
                                a.warn(ctx, "health check check failed: %s", err)
                        }
                },
                HealthCheckInterval:      15 * time.Second,
                DelayedTaskCheckInterval: 5 * time.Second,
                GroupGracePeriod:         1 * time.Minute,
                GroupMaxDelay:            0,
                GroupMaxSize:             0,
                GroupAggregator:          nil,
                DisableRedisConnClose:    true,
        }
        if utils.IsStrNotBlank(a.c.Queue) {
                asynqCfg.Queues = map[string]int{a.c.Queue: 3}
        }

        a.server = asynq.NewServer(wrapper, asynqCfg)
}

func @208:26

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

func(task *asynq.Task, opts []asynq.Option, err error) {
                                        ignored := []error{errDiscardMessage}
                                        if a.locker == nil {
                                                ignored = append(ignored, asynq.ErrDuplicateTask, asynq.ErrTaskIDConflict)
                                        }
                                        if err = utils.ErrIgnore(err, ignored...); err == nil {
                                                return
                                        }
                                        taskName := "unknown"
                                        if task != nil {
                                                taskName = a.unformatTaskName(task.Type())
                                        }
                                        a.warn(ctx, "enqueue task %s failed: %s", taskName, err)
                                }

func Construct

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/construct.go:

func Construct(ctx context.Context, confs map[string]*Conf, opts ...utils.OptionExtender) func() {
        opt := utils.ApplyOptions[config.InitOption](opts...)
        optU := utils.ApplyOptions[useOption](opts...)
        if opt.AppName == "" {
                opt.AppName = optU.appName
        }

        for name, conf := range confs {
                addInstance(ctx, name, conf, opt)
        }
        return func() {
                locker.Lock()
                defer locker.Unlock()

                pid := syscall.Getpid()
                app := config.Use(opt.AppName).AppName()
                if routers != nil {
                        for name, router := range routers[opt.AppName] {
                                log.Printf("%v [Gofusion] %s %s %s exiting...", pid, app, config.ComponentCron, name)
                                if err := router.shutdown(); err == nil {
                                        log.Printf("%v [Gofusion] %s %s %s exited", pid, app, config.ComponentCron, name)
                                } else {
                                        log.Printf("%v [Gofusion] %s %s %s exit failed: %s", pid, app, config.ComponentCron, name, err)
                                }
                        }
                        delete(routers, opt.AppName)
                }
        }
}

func asynqRouter.shutdown

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

func (a *asynqRouter) shutdown() (err error) {
        if a.c.Trigger {
                _, catchErr := utils.Catch(a.trigger.Shutdown)
                err = multierr.Append(err, errors.Cause(catchErr))
        }
        if a.c.Server {
                _, catchErr := utils.Catch(a.server.Shutdown)
                err = multierr.Append(err, errors.Cause(catchErr))
        }
        return
}

func @377:27

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

func(ctx context.Context, raw *asynq.Task) (err error) {
                taskName := a.unformatTaskName(raw.Type())
                inspect.SetField(raw, asyncqTaskTypenameField, taskName)
                if utils.IsStrBlank(fusCtx.GetTraceID(ctx)) {
                        ctx = fusCtx.SetTraceID(ctx, utils.NginxID())
                }
                if utils.IsStrBlank(fusCtx.GetCronTaskName(ctx)) {
                        ctx = fusCtx.SetCronTaskName(ctx, taskName)
                }
                return next.ProcessTask(ctx, raw)
        }

func @344:8

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

func() {
                if e != nil {
                        a.warn(ctx, "post enqueue task %s release lock failed: %s", taskName, e)
                }
        }

func asynqRouter.initTrigger

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

func (a *asynqRouter) initTrigger(ctx context.Context, wrapper *asynqWrapper, logLevel asynq.LogLevel) {
        a.trigger = utils.Must(
                asynq.NewPeriodicTaskManager(asynq.PeriodicTaskManagerOpts{
                        PeriodicTaskConfigProvider: wrapper,
                        RedisConnOpt:               wrapper,
                        SchedulerOpts: &asynq.SchedulerOpts{
                                Logger:                a.logger,
                                LogLevel:              logLevel,
                                Location:              utils.Must(time.LoadLocation(a.c.Timezone)),
                                DisableRedisConnClose: true,
                                PreEnqueueFunc:        a.preEnqueueFunc(ctx),
                                PostEnqueueFunc:       a.postEnqueueFunc(ctx),
                                EnqueueErrorHandler: func(task *asynq.Task, opts []asynq.Option, err error) {
                                        ignored := []error{errDiscardMessage}
                                        if a.locker == nil {
                                                ignored = append(ignored, asynq.ErrDuplicateTask, asynq.ErrTaskIDConflict)
                                        }
                                        if err = utils.ErrIgnore(err, ignored...); err == nil {
                                                return
                                        }
                                        taskName := "unknown"
                                        if task != nil {
                                                taskName = a.unformatTaskName(task.Type())
                                        }
                                        a.warn(ctx, "enqueue task %s failed: %s", taskName, err)
                                },
                        },
                        SyncInterval: utils.Must(time.ParseDuration(a.c.RefreshTasksInterval)),
                }),
        )
        a.id = a.trigger.ID()
}

func asynqRouter.preEnqueueFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

func (a *asynqRouter) preEnqueueFunc(ctx context.Context) func(*asynq.Task, []asynq.Option) error {
        return func(task *asynq.Task, opts []asynq.Option) (err error) {
                // when locker is disabled, we cannot determine which message should be discarded
                if a.locker == nil {
                        return
                }

                taskName := a.unformatTaskName(task.Type())
                lockKey := a.formatLockKey(taskName)
                if err = a.locker.Lock(ctx, lockKey, lock.Expire(tolerantOfTimeNotSync), lock.ReentrantKey(a.id)); err == nil {
                        a.info(ctx, "pre enqueue task %s success", taskName)
                        return
                }

                err = utils.ErrIgnore(err, lock.ErrTimeout, lock.ErrContextDone)
                if err == nil {
                        a.debug(ctx, "pre enqueue discard task %s", taskName)
                        return errDiscardMessage
                }

                a.warn(ctx, "pre enqueue task %s failed: %s", taskName, err)
                return
        }
}

func asynqWrapper.MakeRedisClient

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

491	`func (a *asynqWrapper) MakeRedisClient() any {`
492	`return a.cli`
493	`}`

func asynqRouter.newTask

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

func (a *asynqRouter) newTask(raw *asynq.Task) (t Task) {
        return &task{
                id:         raw.Type(),
                name:       raw.Type(),
                payload:    raw.Payload(),
                rawMessage: raw,
        }
}

func asynqRouter.unformatTaskName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

465	`func (a *asynqRouter) unformatTaskName(taskName string) (result string) {`
466	`return strings.TrimPrefix(taskName, fmt.Sprintf("%s:cron:", config.Use(a.appName).AppName()))`
467	`}`

func task.Name

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/types.go:

97	`func (t *task) Name() string {`
98	`return t.name`
99	`}`

func asynqRouter.postEnqueueFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

func (a *asynqRouter) postEnqueueFunc(ctx context.Context) func(info *asynq.TaskInfo, err error) {
        return func(info *asynq.TaskInfo, err error) {
                // release lock
                if a.locker != nil {
                        defer routine.Go(a.releaseCronTaskLock, routine.Args(ctx, info), routine.AppName(a.appName))
                }

                ignored := []error{errDiscardMessage}
                if a.locker == nil {
                        ignored = append(ignored, asynq.ErrDuplicateTask, asynq.ErrTaskIDConflict)
                }

                if err = utils.ErrIgnore(err, ignored...); err == nil {
                        return
                }
                taskName := "unknown"
                if info != nil {
                        taskName = a.unformatTaskName(info.Type)
                }
                a.debug(ctx, "post enqueue task %s failed: %s", taskName, err)
        }
}

func asynqRouter.formatTaskName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

462	`func (a *asynqRouter) formatTaskName(taskName string) (result string) {`
463	`return fmt.Sprintf("%s:cron:%s", config.Use(a.appName).AppName(), taskName)`
464	`}`

func asynqRouter.formatLockKey

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

459	`func (a *asynqRouter) formatLockKey(taskName string) string {`
460	`return fmt.Sprintf("cron_%s", taskName)`
461	`}`

func init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

593	`func init() {`
594	`rand.Seed(time.Now().UnixMicro())`
595	`}`

func asynqRouter.gatewayMiddleware

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

func (a *asynqRouter) gatewayMiddleware(next asynq.Handler) asynq.Handler {
        return asynq.HandlerFunc(func(ctx context.Context, raw *asynq.Task) (err error) {
                taskName := a.unformatTaskName(raw.Type())
                inspect.SetField(raw, asyncqTaskTypenameField, taskName)
                if utils.IsStrBlank(fusCtx.GetTraceID(ctx)) {
                        ctx = fusCtx.SetTraceID(ctx, utils.NginxID())
                }
                if utils.IsStrBlank(fusCtx.GetCronTaskName(ctx)) {
                        ctx = fusCtx.SetCronTaskName(ctx, taskName)
                }
                return next.ProcessTask(ctx, raw)
        })
}

func AppName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/construct.go:

func AppName(name string) utils.OptionFunc[useOption] {
        return func(o *useOption) {
                o.appName = name
        }
}

func asynqRouter.format

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/log.go:

48	`func (a *asynqRouter) format(src string) (dst string) {`
49	`return fmt.Sprintf("%v [Gofusion] %s %s asynq(%s) %s",`
50	`syscall.Getpid(), config.ComponentCron, a.n, a.id, src)`
51	`}`

func asynqRouter.defaultQueue

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

456	`func (a *asynqRouter) defaultQueue() (result string) {`
457	`return fmt.Sprintf("%s:cron", config.Use(a.appName).AppName())`
458	`}`

func @89:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/construct.go:

89	`func(o *useOption) {`
90	`o.appName = name`
91	`}`

func @404:10

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

404	`func(ctx context.Context, raw *asynq.Task) (err error) {`
405	`return fn(ctx, a.newTask(raw))`
406	`}`

func @409:10

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

409	`func(ctx context.Context, raw *asynq.Task) (err error) {`
410	`return fn(ctx, a.newTask(raw))`
411	`}`

func init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/construct.go:

111	`func init() {`
112	`config.AddComponent(config.ComponentCron, Construct)`
113	`}`

func @33:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/construct.go:

func() {
                locker.Lock()
                defer locker.Unlock()

                pid := syscall.Getpid()
                app := config.Use(opt.AppName).AppName()
                if routers != nil {
                        for name, router := range routers[opt.AppName] {
                                log.Printf("%v [Gofusion] %s %s %s exiting...", pid, app, config.ComponentCron, name)
                                if err := router.shutdown(); err == nil {
                                        log.Printf("%v [Gofusion] %s %s %s exited", pid, app, config.ComponentCron, name)
                                } else {
                                        log.Printf("%v [Gofusion] %s %s %s exit failed: %s", pid, app, config.ComponentCron, name, err)
                                }
                        }
                        delete(routers, opt.AppName)
                }
        }

func @302:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

func(info *asynq.TaskInfo, err error) {
                // release lock
                if a.locker != nil {
                        defer routine.Go(a.releaseCronTaskLock, routine.Args(ctx, info), routine.AppName(a.appName))
                }

                ignored := []error{errDiscardMessage}
                if a.locker == nil {
                        ignored = append(ignored, asynq.ErrDuplicateTask, asynq.ErrTaskIDConflict)
                }

                if err = utils.ErrIgnore(err, ignored...); err == nil {
                        return
                }
                taskName := "unknown"
                if info != nil {
                        taskName = a.unformatTaskName(info.Type)
                }
                a.debug(ctx, "post enqueue task %s failed: %s", taskName, err)
        }

func addInstance

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/construct.go:

func addInstance(ctx context.Context, name string, conf *Conf, opt *config.InitOption) {
        var r IRouter
        switch conf.Type {
        case schedulerTypeAsynq:
                r = newAsynq(ctx, opt.AppName, name, conf)
        default:
                panic(ErrUnsupportedSchedulerType)
        }

        locker.Lock()
        defer locker.Unlock()
        if routers == nil {
                routers = make(map[string]map[string]IRouter)
        }
        if routers[opt.AppName] == nil {
                routers[opt.AppName] = make(map[string]IRouter)
        }
        if _, ok := routers[opt.AppName][name]; ok {
                panic(errors.Errorf("duplicated cron name: %s", name))
        }
        routers[opt.AppName][name] = r

        // ioc
        if opt.DI != nil {
                opt.DI.MustProvide(
                        func() IRouter { return Use(name, AppName(opt.AppName)) },
                        di.Name(name),
                )
        }
}

func asynqRouter.info

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/log.go:

func (a *asynqRouter) info(ctx context.Context, msg string, args ...any) {
        msg = a.format(msg)
        if a.logger == nil {
                log.Printf(msg, args...)
        } else {
                logArgs := make([]any, 0, len(args)+2)
                logArgs = append(logArgs, ctx, msg)
                logArgs = append(logArgs, args...)
                a.logger.Info(logArgs...)
        }
}

func asynqRouter.debug

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/log.go:

func (a *asynqRouter) debug(ctx context.Context, msg string, args ...any) {
        msg = a.format(msg)
        if a.logger == nil {
                log.Printf(msg, args...)
        } else {
                logArgs := make([]any, 0, len(args)+2)
                logArgs = append(logArgs, ctx, msg)
                logArgs = append(logArgs, args...)
                a.logger.Debug(logArgs...)
        }
}

func asynqWrapper.getTaskExecuteInterval

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

func (a *asynqWrapper) getTaskExecuteInterval(spec string) (interval time.Duration, err error) {
        now := time.Now()
        scheduler, err := cron.ParseStandard(spec)
        if err != nil {
                return 0, err
        }
        next := scheduler.Next(now)
        interval = scheduler.Next(next).Sub(next)
        return
}

func asynqRouter.warn

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/log.go:

func (a *asynqRouter) warn(ctx context.Context, msg string, args ...any) {
        msg = a.format(msg)
        if a.logger == nil {
                log.Printf(msg, args...)
        } else {
                logArgs := make([]any, 0, len(args)+2)
                logArgs = append(logArgs, ctx, msg)
                logArgs = append(logArgs, args...)
                a.logger.Warn(logArgs...)
        }
}

func asynqWrapper.GetConfigs

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

func (a *asynqWrapper) GetConfigs() (result []*asynq.PeriodicTaskConfig, err error) {
        result, err = a.getConfigs()
        if err != nil {
                return
        }

        a.r.l.Lock()
        defer a.r.l.Unlock()
        for _, cfg := range result {
                // renaming
                taskName := inspect.GetField[string](cfg.Task, asyncqTaskTypenameField)
                inspect.SetField(cfg.Task, asyncqTaskTypenameField, a.r.formatTaskName(taskName))

                name := cfg.Task.Type()
                a.r.lockDurations[name], err = a.getTaskExecuteInterval(cfg.Cronspec)
                if err != nil {
                        return
                }
        }

        return
}

func asynqRouter.releaseCronTaskLock

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

func (a *asynqRouter) releaseCronTaskLock(ctx context.Context, info *asynq.TaskInfo) {
        if info == nil {
                return
        }
        taskName := a.unformatTaskName(info.Type)

        // 90 ~ 100ms jitter
        jitter := 90*time.Millisecond + time.Duration(float64(10*time.Millisecond)*rand.Float64())

        a.l.RLock()
        lockTime := a.lockDurations[info.Type]
        a.l.RUnlock()

        // prevent a negative tolerant
        tolerant := utils.Min(tolerantOfTimeNotSync, lockTime) - jitter
        tolerant = utils.Max(tolerant, 500*time.Millisecond)
        timer := time.NewTimer(tolerant)
        defer timer.Stop()

        var e error
        defer func() {
                if e != nil {
                        a.warn(ctx, "post enqueue task %s release lock failed: %s", taskName, e)
                }
        }()

        now := time.Now()
        unlockKey := a.formatLockKey(taskName)
        for {
                select {
                case <-ctx.Done():
                        a.debug(ctx, "post enqueue task %s release lock: context done", taskName)
                        e = a.locker.Unlock(ctx, unlockKey, lock.ReentrantKey(a.id))
                        return
                case <-timer.C:
                        e = a.locker.Unlock(ctx, unlockKey, lock.ReentrantKey(a.id))
                        return
                default:
                        a.l.RLock()
                        newLockTime := a.lockDurations[info.Type]
                        a.l.RUnlock()
                        if newLockTime != lockTime {
                                lockTime = newLockTime
                                tolerant = utils.Min(tolerantOfTimeNotSync, lockTime) - jitter
                                tolerant = utils.Max(tolerant, 500*time.Millisecond)
                                tolerant = utils.Max(0, tolerant-time.Since(now))
                                timer.Reset(tolerant)
                        }
                }
        }
}

func Use

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/construct.go:

func Use(name string, opts ...utils.OptionExtender) IRouter {
        opt := utils.ApplyOptions[useOption](opts...)

        locker.RLock()
        defer locker.RUnlock()
        routers, ok := routers[opt.appName]
        if !ok {
                panic(errors.Errorf("cron router instance not found for app: %s", opt.appName))
        }

        router, ok := routers[name]
        if !ok {
                panic(errors.Errorf("cron router instance not found for name: %s", name))
        }
        return router
}

func asynqRouter.Start

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

func (a *asynqRouter) Start() (err error) {
        defer a.info(context.Background(), "scheduler started")

        if a.c.Trigger {
                if err = a.trigger.Start(); err != nil {
                        return
                }
        }

        if a.c.Server {
                a.ServeMux.Use(a.gatewayMiddleware)
                a.ServeMux.Use(a.mws...)
                if err = a.server.Start(a.ServeMux); err != nil {
                        return
                }
        }

        return
}

func newAsynq

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

func newAsynq(ctx context.Context, appName, name string, conf *Conf) IRouter {
        r := &asynqRouter{
                appName:               appName,
                n:                     name,
                c:                     conf,
                lockDurations:         make(map[string]time.Duration, len(conf.Tasks)),
                shouldShutdownServer:  true,
                shouldShutdownTrigger: true,
        }
        if utils.IsStrBlank(r.c.Queue) {
                r.c.Queue = r.defaultQueue()
        }

        var rdsCli rdsDrv.UniversalClient
        switch conf.InstanceType {
        case instanceTypeRedis:
                rdsCli = redis.Use(ctx, conf.Instance, redis.AppName(appName))
        case instanceTypeMysql:
                fallthrough
        default:
                panic(errors.Errorf("unknown instance type: %s", conf.InstanceType))
        }

        if r.logger == nil && utils.IsStrNotBlank(conf.Logger) {
                loggerType := inspect.TypeOf(conf.Logger)
                loggerValue := reflect.New(loggerType)
                if loggerValue.Type().Implements(customLoggerType) {
                        logger := log.Use(conf.LogInstance, log.AppName(appName))
                        loggerValue.Interface().(customLogger).Init(logger, appName, name)
                }
                r.logger = loggerValue.Convert(asynqLoggerType).Interface().(asynq.Logger)
        }
        if r.locker == nil && utils.IsStrNotBlank(conf.LockInstance) {
                r.locker = lock.Use(conf.LockInstance, lock.AppName(appName))
                if r.locker == nil {
                        panic(errors.Errorf("locker instance not found: %s", conf.LockInstance))
                }
        }

        var provider asynq.PeriodicTaskConfigProvider
        if utils.IsStrNotBlank(conf.TaskLoader) {
                loaderType := inspect.TypeOf(conf.TaskLoader)
                if loaderType == nil {
                        panic(errors.Errorf("%s not found", conf.TaskLoader))
                }
                provider = reflect.New(loaderType).
                        Convert(asynqPeriodicTaskConfigProviderType).Interface().(asynq.PeriodicTaskConfigProvider)
        }

        logLevel := asynq.LogLevel(0)
        utils.MustSuccess(logLevel.Set(conf.LogLevel))

        wrapper := &asynqWrapper{r: r, n: r.n, appName: appName, cli: rdsCli, provider: provider}
        if conf.Trigger {
                r.initTrigger(ctx, wrapper, logLevel)
        }
        if conf.Server {
                r.initServer(ctx, wrapper, logLevel)
        }

        return r
}

func @429:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

func(ctx context.Context, raw *asynq.Task) (err error) {
                if !hasArg {
                        return fn(ctx)
                }
                arg := reflect.New(argType)
                payload := raw.Payload()
                if len(payload) == 0 {
                        payload = []byte("null")
                }
                if err = json.Unmarshal(payload, arg.Interface()); err != nil {
                        return
                }
                arg = arg.Elem()
                for i := 0; i < argTypePtrDepth; i++ {
                        arg = arg.Addr()
                }

                return fn(ctx, arg.Interface())
        }

func asynqWrapper.getConfigs

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

func (a *asynqWrapper) getConfigs() (result []*asynq.PeriodicTaskConfig, err error) {
        if a.provider != nil {
                result, err = a.provider.GetConfigs()
                if err != nil {
                        return
                }
        }

        var confs map[string]*Conf
        if err = config.Use(a.appName).LoadComponentConfig(config.ComponentCron, &confs); err != nil {
                return
        }
        conf, ok := confs[a.n]
        if !ok {
                return nil, errors.Errorf("%s cron config not found", a.n)
        }

        loc, _ := time.LoadLocation(a.r.c.Timezone)
        if loc == nil {
                loc = constant.DefaultLocation()
        }

        queue := conf.Queue
        if utils.IsStrBlank(queue) {
                queue = a.r.c.Queue
        }
        for name, cfg := range conf.Tasks {
                var (
                        deadline          time.Time
                        interval, timeout time.Duration
                        opts              []asynq.Option
                )
                if interval, err = a.getTaskExecuteInterval(cfg.Crontab); err != nil {
                        return
                }
                if utils.IsStrNotBlank(cfg.Timeout) {
                        if timeout, err = time.ParseDuration(cfg.Timeout); err != nil {
                                return
                        }
                        opts = append(opts, asynq.Timeout(timeout))
                } else {
                        opts = append(opts, asynq.Timeout(interval))
                }
                if utils.IsStrNotBlank(cfg.Deadline) {
                        if deadline, err = time.ParseInLocation(constant.StdTimeLayout, cfg.Deadline, loc); err != nil {
                                return
                        }
                        opts = append(opts, asynq.Deadline(deadline))
                }

                result = append(result, &asynq.PeriodicTaskConfig{
                        Cronspec: cfg.Crontab,
                        Task:     asynq.NewTask(name, []byte(cfg.Payload)),
                        Opts: append(opts, []asynq.Option{
                                asynq.TaskID(name),
                                asynq.Unique(utils.Min(interval, tolerantOfTimeNotSync)),
                                asynq.Queue(queue),
                                asynq.MaxRetry(utils.Max(0, cfg.Retry)),
                        }...),
                })
        }
        return
}

func asynqRouter.Handle

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

func (a *asynqRouter) Handle(pattern string, fn any, _ ...utils.OptionExtender) {
        if !a.c.Server {
                a.debug(context.Background(), "cannot handle task %s: client is not enabled", a.n)
                return
        }

        a.ServeMux.Handle(a.formatTaskName(pattern), a.adaptAsynqHandlerFunc(fn))
}

func asynqRouter.Serve

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

func (a *asynqRouter) Serve() (err error) {
        defer a.info(context.Background(), "scheduler is running")

        if a.c.Server {
                a.ServeMux.Use(a.gatewayMiddleware)
                a.ServeMux.Use(a.mws...)
        }

        if a.c.Trigger && !a.c.Server {
                return a.trigger.Run()
        }
        if !a.c.Trigger && a.c.Server {
                return a.server.Run(a.ServeMux)
        }

        a.shouldShutdownServer = false
        if err = a.trigger.Start(); err != nil {
                return
        }

        return a.server.Run(a.ServeMux)
}

func @246:40

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

func(ctx context.Context, task *asynq.Task, err error) {
                        taskName := "unknown"
                        if task != nil {
                                taskName = a.unformatTaskName(task.Type())
                        }
                        a.info(ctx, "handle task %s message error %s", taskName, err)
                }

func @391:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

391	`func(asynqNext asynq.Handler) asynq.Handler {`
392	`next := mw(a.adaptRouterHandlerFunc(asynqNext))`
393	`return a.adaptAsynqHandlerFunc(next)`
394	`}`

func @256:20

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

func(err error) {
                        if err != nil {
                                a.warn(ctx, "health check check failed: %s", err)
                        }
                }

func asynqRouter.Use

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

func (a *asynqRouter) Use(mws ...routerMiddleware) {
        for _, mw := range mws {
                a.mws = append(a.mws, a.adaptMiddleware(mw))
        }
}

func @451:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

451	`func(ctx context.Context, raw Task) (err error) {`
452	`return h.ProcessTask(ctx, a.newAsynqTask(raw))`
453	`}`

func @78:4

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/construct.go:

78	`func() IRouter { return Use(name, AppName(opt.AppName)) }`

func asynqRouter.newAsynqTask

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

478	`func (a asynqRouter) newAsynqTask(raw Task) (t asynq.Task) {`
479	`return raw.RawMessage().(*asynq.Task)`
480	`}`

func asynqRouter.adaptRouterHandlerFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

func (a *asynqRouter) adaptRouterHandlerFunc(h asynq.Handler) routerHandleFunc {
        return func(ctx context.Context, raw Task) (err error) {
                return h.ProcessTask(ctx, a.newAsynqTask(raw))
        }
}

func asynqRouter.adaptMiddleware

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

func (a *asynqRouter) adaptMiddleware(mw routerMiddleware) asynq.MiddlewareFunc {
        return func(asynqNext asynq.Handler) asynq.Handler {
                next := mw(a.adaptRouterHandlerFunc(asynqNext))
                return a.adaptAsynqHandlerFunc(next)
        }
}

func task.ID

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/types.go:

93	`func (t *task) ID() string {`
94	`return t.id`
95	`}`

func @243:19

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/asynq.go:

243	`func(err error) bool { return !errors.Is(err, errDiscardMessage) }`

func task.Payload

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/types.go:

101	`func (t *task) Payload() []byte {`
102	`return t.payload`
103	`}`

func task.RawMessage

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/cron/types.go:

105	`func (t *task) RawMessage() any {`
106	`return t.rawMessage`
107	`}`

Package Overview: github.com/wfusion/gofusion/db 51.8%

Please select a function to see what's left for testing.

`startDaemonRoutines(...)`	`github.com/wfusion/gofusion/db/metrics.go`	`100.0%`	`10/10`
`Construct(...)`	`github.com/wfusion/gofusion/db/construct.go`	`100.0%`	`9/9`
`.QueryFirst(...)`	`github.com/wfusion/gofusion/db/dal.go`	`100.0%`	`7/7`
`@60:9(...)`	`github.com/wfusion/gofusion/db/candy.go`	`100.0%`	`3/3`
`.unscopedGormDB(...)`	`github.com/wfusion/gofusion/db/dal.go`	`100.0%`	`3/3`
`.InsertOne(...)`	`github.com/wfusion/gofusion/db/dal.go`	`100.0%`	`3/3`
`@32:4(...)`	`github.com/wfusion/gofusion/db/tx.go`	`100.0%`	`2/2`
`@16:23(...)`	`github.com/wfusion/gofusion/db/ctx.go`	`100.0%`	`2/2`
`GetCtxGormDBByName(...)`	`github.com/wfusion/gofusion/db/ctx.go`	`100.0%`	`2/2`
`ScanCursor(...)`	`github.com/wfusion/gofusion/db/candy.go`	`100.0%`	`1/1`
`ScanBatch(...)`	`github.com/wfusion/gofusion/db/candy.go`	`100.0%`	`1/1`
`@74:9(...)`	`github.com/wfusion/gofusion/db/candy.go`	`100.0%`	`1/1`
`@17:9(...)`	`github.com/wfusion/gofusion/db/tx.go`	`100.0%`	`1/1`
`TxUse(...)`	`github.com/wfusion/gofusion/db/tx.go`	`100.0%`	`1/1`
`AppName(...)`	`github.com/wfusion/gofusion/db/db.go`	`100.0%`	`1/1`
`ScanDAL(...)`	`github.com/wfusion/gofusion/db/candy.go`	`100.0%`	`1/1`
`Instance.GetProxy(...)`	`github.com/wfusion/gofusion/db/db.go`	`100.0%`	`1/1`
`@406:46(...)`	`github.com/wfusion/gofusion/db/dal.go`	`100.0%`	`1/1`
`@173:41(...)`	`github.com/wfusion/gofusion/db/candy.go`	`100.0%`	`1/1`
`.Model(...)`	`github.com/wfusion/gofusion/db/dal.go`	`100.0%`	`1/1`
`@40:41(...)`	`github.com/wfusion/gofusion/db/tx.go`	`100.0%`	`1/1`
`@41:9(...)`	`github.com/wfusion/gofusion/db/candy.go`	`100.0%`	`1/1`
`@68:9(...)`	`github.com/wfusion/gofusion/db/candy.go`	`100.0%`	`1/1`
`@401:82(...)`	`github.com/wfusion/gofusion/db/dal.go`	`100.0%`	`1/1`
`mysqlSoftDelete(...)`	`github.com/wfusion/gofusion/db/construct.go`	`100.0%`	`1/1`
`init(...)`	`github.com/wfusion/gofusion/db/construct.go`	`100.0%`	`1/1`
`GetCtxGormDB(...)`	`github.com/wfusion/gofusion/db/ctx.go`	`100.0%`	`1/1`
`ScanOrder(...)`	`github.com/wfusion/gofusion/db/candy.go`	`100.0%`	`1/1`
`@46:9(...)`	`github.com/wfusion/gofusion/db/db.go`	`100.0%`	`1/1`
`SetCtxGormDB(...)`	`github.com/wfusion/gofusion/db/ctx.go`	`100.0%`	`1/1`
`Unscoped(...)`	`github.com/wfusion/gofusion/db/dal.go`	`100.0%`	`1/1`
`@459:9(...)`	`github.com/wfusion/gofusion/db/dal.go`	`100.0%`	`1/1`
`.CanIgnore(...)`	`github.com/wfusion/gofusion/db/dal.go`	`100.0%`	`1/1`
`addInstance(...)`	`github.com/wfusion/gofusion/db/construct.go`	`94.7%`	`36/38`
`adaptMysqlAutoIncrementIncrement(...)`	`github.com/wfusion/gofusion/db/construct.go`	`88.9%`	`8/9`
`.Delete(...)`	`github.com/wfusion/gofusion/db/dal.go`	`87.5%`	`14/16`
`@45:9(...)`	`github.com/wfusion/gofusion/db/construct.go`	`86.7%`	`13/15`
`.ShardingIDGen(...)`	`github.com/wfusion/gofusion/db/dal.go`	`83.3%`	`5/6`
`Use(...)`	`github.com/wfusion/gofusion/db/db.go`	`80.0%`	`8/10`
`.parseOptionFromArgs(...)`	`github.com/wfusion/gofusion/db/dal.go`	`80.0%`	`8/10`
`NewDAL(...)`	`github.com/wfusion/gofusion/db/dal.go`	`80.0%`	`4/5`
`.InsertInBatches(...)`	`github.com/wfusion/gofusion/db/dal.go`	`77.8%`	`7/9`
`WithinTx(...)`	`github.com/wfusion/gofusion/db/tx.go`	`77.8%`	`7/9`
`.tableName(...)`	`github.com/wfusion/gofusion/db/dal.go`	`77.8%`	`7/9`
`.writeWithTableSharding(...)`	`github.com/wfusion/gofusion/db/dal.go`	`75.0%`	`9/12`
`.WriteDB(...)`	`github.com/wfusion/gofusion/db/dal.go`	`75.0%`	`3/4`
`@116:21(...)`	`github.com/wfusion/gofusion/db/metrics.go`	`73.9%`	`17/23`
`@58:21(...)`	`github.com/wfusion/gofusion/db/metrics.go`	`73.5%`	`25/34`
`.Save(...)`	`github.com/wfusion/gofusion/db/dal.go`	`71.4%`	`10/14`
`.ReadDB(...)`	`github.com/wfusion/gofusion/db/dal.go`	`71.4%`	`5/7`
`Business.BeforeCreate(...)`	`github.com/wfusion/gofusion/db/model.go`	`66.7%`	`4/6`
`metricDBStats(...)`	`github.com/wfusion/gofusion/db/metrics.go`	`66.7%`	`2/3`
`.writeDB(...)`	`github.com/wfusion/gofusion/db/dal.go`	`66.7%`	`2/3`
`metricDBLatency(...)`	`github.com/wfusion/gofusion/db/metrics.go`	`66.7%`	`2/3`
`.IgnoreErr(...)`	`github.com/wfusion/gofusion/db/dal.go`	`66.7%`	`2/3`
`Scan(...)`	`github.com/wfusion/gofusion/db/candy.go`	`58.6%`	`34/58`
`BusinessSoftDeleted.BeforeCreate(...)`	`github.com/wfusion/gofusion/db/model.go`	`57.1%`	`4/7`
`.convertAnyToTS(...)`	`github.com/wfusion/gofusion/db/dal.go`	`50.0%`	`6/12`
`@206:9(...)`	`github.com/wfusion/gofusion/db/model.go`	`0.0%`	`0/16`
`@239:9(...)`	`github.com/wfusion/gofusion/db/model.go`	`0.0%`	`0/15`
`.ShardingByModelList(...)`	`github.com/wfusion/gofusion/db/dal.go`	`0.0%`	`0/15`
`.ShardingIDListGen(...)`	`github.com/wfusion/gofusion/db/dal.go`	`0.0%`	`0/12`
`.QueryInBatches(...)`	`github.com/wfusion/gofusion/db/dal.go`	`0.0%`	`0/8`
`.Query(...)`	`github.com/wfusion/gofusion/db/dal.go`	`0.0%`	`0/7`
`.Count(...)`	`github.com/wfusion/gofusion/db/dal.go`	`0.0%`	`0/7`
`.QueryLast(...)`	`github.com/wfusion/gofusion/db/dal.go`	`0.0%`	`0/7`
`.Transaction(...)`	`github.com/wfusion/gofusion/db/dal.go`	`0.0%`	`0/7`
`.ShardingByValues(...)`	`github.com/wfusion/gofusion/db/dal.go`	`0.0%`	`0/6`
`Data.Equals(...)`	`github.com/wfusion/gofusion/db/model.go`	`0.0%`	`0/5`
`Business.Equals(...)`	`github.com/wfusion/gofusion/db/model.go`	`0.0%`	`0/5`
`BusinessSoftDeleted.Equals(...)`	`github.com/wfusion/gofusion/db/model.go`	`0.0%`	`0/5`
`DataSoftDeleted.Equals(...)`	`github.com/wfusion/gofusion/db/model.go`	`0.0%`	`0/5`
`.Take(...)`	`github.com/wfusion/gofusion/db/dal.go`	`0.0%`	`0/4`
`.Pluck(...)`	`github.com/wfusion/gofusion/db/dal.go`	`0.0%`	`0/4`
`.Updates(...)`	`github.com/wfusion/gofusion/db/dal.go`	`0.0%`	`0/4`
`.Update(...)`	`github.com/wfusion/gofusion/db/dal.go`	`0.0%`	`0/4`
`.FirstOrCreate(...)`	`github.com/wfusion/gofusion/db/dal.go`	`0.0%`	`0/4`
`.SetCtxWriteDB(...)`	`github.com/wfusion/gofusion/db/dal.go`	`0.0%`	`0/3`
`.SetCtxReadDB(...)`	`github.com/wfusion/gofusion/db/dal.go`	`0.0%`	`0/3`
`DataSoftDeleted.DeleteTime(...)`	`github.com/wfusion/gofusion/db/model.go`	`0.0%`	`0/3`
`BusinessSoftDeleted.Clone(...)`	`github.com/wfusion/gofusion/db/model.go`	`0.0%`	`0/3`
`Data.Clone(...)`	`github.com/wfusion/gofusion/db/model.go`	`0.0%`	`0/3`
`Business.Clone(...)`	`github.com/wfusion/gofusion/db/model.go`	`0.0%`	`0/3`
`@141:4(...)`	`github.com/wfusion/gofusion/db/construct.go`	`0.0%`	`0/3`
`DataSoftDeleted.Clone(...)`	`github.com/wfusion/gofusion/db/model.go`	`0.0%`	`0/3`
`@53:9(...)`	`github.com/wfusion/gofusion/db/candy.go`	`0.0%`	`0/2`
`@116:3(...)`	`github.com/wfusion/gofusion/db/dal.go`	`0.0%`	`0/2`
`@33:4(...)`	`github.com/wfusion/gofusion/db/tx.go`	`0.0%`	`0/2`
`@372:82(...)`	`github.com/wfusion/gofusion/db/dal.go`	`0.0%`	`0/1`
`Data.ModifyTime(...)`	`github.com/wfusion/gofusion/db/model.go`	`0.0%`	`0/1`
`DataSoftDeleted.CreateTime(...)`	`github.com/wfusion/gofusion/db/model.go`	`0.0%`	`0/1`
`DataSoftDeleted.ModifyTime(...)`	`github.com/wfusion/gofusion/db/model.go`	`0.0%`	`0/1`
`Data.CreateTime(...)`	`github.com/wfusion/gofusion/db/model.go`	`0.0%`	`0/1`
`@471:9(...)`	`github.com/wfusion/gofusion/db/dal.go`	`0.0%`	`0/1`
`WriteDB(...)`	`github.com/wfusion/gofusion/db/dal.go`	`0.0%`	`0/1`
`@465:9(...)`	`github.com/wfusion/gofusion/db/dal.go`	`0.0%`	`0/1`
`Business.BeforeCreateFn(...)`	`github.com/wfusion/gofusion/db/model.go`	`0.0%`	`0/1`
`@116:9(...)`	`github.com/wfusion/gofusion/db/model.go`	`0.0%`	`0/1`
`Business.BizCreateTime(...)`	`github.com/wfusion/gofusion/db/model.go`	`0.0%`	`0/1`
`Business.BizModifyTime(...)`	`github.com/wfusion/gofusion/db/model.go`	`0.0%`	`0/1`
`Clauses(...)`	`github.com/wfusion/gofusion/db/dal.go`	`0.0%`	`0/1`
`@435:36(...)`	`github.com/wfusion/gofusion/db/dal.go`	`0.0%`	`0/1`
`@379:56(...)`	`github.com/wfusion/gofusion/db/dal.go`	`0.0%`	`0/1`
`BusinessSoftDeleted.BeforeCreateFn(...)`	`github.com/wfusion/gofusion/db/model.go`	`0.0%`	`0/1`
`@170:9(...)`	`github.com/wfusion/gofusion/db/model.go`	`0.0%`	`0/1`
`.ModelSlice(...)`	`github.com/wfusion/gofusion/db/dal.go`	`0.0%`	`0/1`
`BusinessSoftDeleted.BizModifyTime(...)`	`github.com/wfusion/gofusion/db/model.go`	`0.0%`	`0/1`
`@273:74(...)`	`github.com/wfusion/gofusion/db/dal.go`	`0.0%`	`0/1`
`@86:9(...)`	`github.com/wfusion/gofusion/db/candy.go`	`0.0%`	`0/1`
`CheckGormErrorFn(...)`	`github.com/wfusion/gofusion/db/model.go`	`0.0%`	`0/1`
`@204:58(...)`	`github.com/wfusion/gofusion/db/model.go`	`0.0%`	`0/1`
`JsonUnmarshalFn(...)`	`github.com/wfusion/gofusion/db/model.go`	`0.0%`	`0/1`
`@137:9(...)`	`github.com/wfusion/gofusion/db/candy.go`	`0.0%`	`0/1`
`JsonMarshalFn(...)`	`github.com/wfusion/gofusion/db/model.go`	`0.0%`	`0/1`
`ScanLog(...)`	`github.com/wfusion/gofusion/db/candy.go`	`0.0%`	`0/1`
`@80:9(...)`	`github.com/wfusion/gofusion/db/candy.go`	`0.0%`	`0/1`
`ScanLimit(...)`	`github.com/wfusion/gofusion/db/candy.go`	`0.0%`	`0/1`
`ScanWhere(...)`	`github.com/wfusion/gofusion/db/candy.go`	`0.0%`	`0/1`
`@47:9(...)`	`github.com/wfusion/gofusion/db/candy.go`	`0.0%`	`0/1`
`ScanUse(...)`	`github.com/wfusion/gofusion/db/candy.go`	`0.0%`	`0/1`
`BusinessSoftDeleted.BizCreateTime(...)`	`github.com/wfusion/gofusion/db/model.go`	`0.0%`	`0/1`

func startDaemonRoutines

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/metrics.go:

func startDaemonRoutines(ctx context.Context, appName, name string, conf *Conf) {
        ticker := time.Tick(time.Second * 5)
        app := config.Use(appName).AppName()
        labels := []metrics.Label{
                {Key: "config", Value: name},
                {Key: "database", Value: conf.DB},
        }

        log.Printf("%v [Gofusion] %s %s %s metrics start", syscall.Getpid(), app, config.ComponentDB, name)
        for {
                select {
                case <-ctx.Done():
                        log.Printf("%v [Gofusion] %s %s %s metrics exited",
                                syscall.Getpid(), app, config.ComponentDB, name)
                        return
                case <-ticker:
                        go metricDBStats(ctx, appName, name, labels)
                        go metricDBLatency(ctx, appName, name, labels)
                }
        }
}

func Construct

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/construct.go:

func Construct(ctx context.Context, confs map[string]*Conf, opts ...utils.OptionExtender) func() {
        opt := utils.ApplyOptions[config.InitOption](opts...)
        optU := utils.ApplyOptions[useOption](opts...)
        if opt.AppName == "" {
                opt.AppName = optU.appName
        }

        for name, conf := range confs {
                addInstance(ctx, name, conf, opt)
        }
        // patch delete at
        patches := make([]*gomonkey.Patches, 0, len(confs))
        patches = append(patches, softdelete.PatchGormDeleteAt())

        return func() {
                rwlock.Lock()
                defer rwlock.Unlock()

                pid := syscall.Getpid()
                app := config.Use(opt.AppName).AppName()
                if appInstances != nil {
                        for _, instance := range appInstances[opt.AppName] {
                                if sqlDB, err := instance.GetProxy().DB(); err == nil {
                                        if err := sqlDB.Close(); err != nil {
                                                log.Printf("%v [Gofusion] %s %s close error: %s", pid, app, config.ComponentDB, err)
                                        }
                                }
                        }
                        delete(appInstances, opt.AppName)
                }
                if len(appInstances) == 0 {
                        for _, patch := range patches {
                                if patch != nil {
                                        patch.Reset()
                                }
                        }
                        softdelete.PatchGormDeleteAtOnce = new(sync.Once)
                }
        }
}

func .QueryFirst

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func (d *dal[T, TS]) QueryFirst(ctx context.Context, query any, args ...any) (*T, error) {
        o, args := d.parseOptionFromArgs(args...)
        ctx = context.WithValue(ctx, fusCtx.KeyDALOption, o)

        found := d.Model()
        result := d.ReadDB(ctx).Clauses(o.clauses...).Where(query, args...).First(found)
        if d.CanIgnore(result.Error) {
                return nil, nil
        }
        return found, d.IgnoreErr(result.Error)
}

func @60:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/candy.go:

func(o *scanOption) {
                o.cursors = cursors
                o.cursorWhere = cursorWhere
                o.cursorColumns = cursorColumns
        }

func .unscopedGormDB

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func (d *dal[T, TS]) unscopedGormDB(src *gorm.DB, o *mysqlDALOption) (dst *gorm.DB) {
        if o != nil && o.unscoped {
                return src.Unscoped()
        }
        return src
}

func .InsertOne

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func (d *dal[T, TS]) InsertOne(ctx context.Context, mod *T, opts ...utils.OptionExtender) error {
        o := utils.ApplyOptions[mysqlDALOption](opts...)
        ctx = context.WithValue(ctx, fusCtx.KeyDALOption, o)
        return d.WriteDB(ctx).Clauses(o.clauses...).Create(mod).Error
}

func @32:4

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/tx.go:

32	`func() bool { db = GetCtxGormDBByName(ctx, opt.dbName); return db != nil }`

func @16:23

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/ctx.go:

16	`func(ctx context.Context) bool {`
17	`db = utils.GetCtxAny(ctx, fusCtx.KeyGormDB, (*DB)(nil))`
18	`return db != nil && db.Name == name`
19	`}`

func GetCtxGormDBByName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/ctx.go:

func GetCtxGormDBByName(ctx context.Context, name string) (db *DB) {
        utils.TravelCtx(ctx, func(ctx context.Context) bool {
                db = utils.GetCtxAny(ctx, fusCtx.KeyGormDB, (*DB)(nil))
                return db != nil && db.Name == name
        })
        return
}

func ScanCursor

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/candy.go:

func ScanCursor(cursorWhere any, cursorColumns []string, cursors ...any) utils.OptionFunc[scanOption] {
        return func(o *scanOption) {
                o.cursors = cursors
                o.cursorWhere = cursorWhere
                o.cursorColumns = cursorColumns
        }
}

func ScanBatch

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/candy.go:

func ScanBatch(batch int) utils.OptionFunc[scanOption] {
        return func(o *scanOption) {
                o.batch = batch
        }
}

func @74:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/candy.go:

74	`func(o *scanOption) {`
75	`o.batch = batch`
76	`}`

func @17:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/tx.go:

17	`func(o *txOption) {`
18	`o.dbName = name`
19	`}`

func TxUse

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/tx.go:

func TxUse(name string) utils.OptionFunc[txOption] {
        return func(o *txOption) {
                o.dbName = name
        }
}

func AppName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/db.go:

func AppName(name string) utils.OptionFunc[useOption] {
        return func(o *useOption) {
                o.appName = name
        }
}

func ScanDAL

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/candy.go:

func ScanDAL[T any, TS ~[]*T](dal DalInterface[T, TS]) utils.OptionFunc[scanOptionGeneric[T, TS]] {
        return func(o *scanOptionGeneric[T, TS]) {
                o.dal = dal
        }
}

func Instance.GetProxy

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/db.go:

31	`func (d Instance) GetProxy() gorm.DB {`
32	`return d.db.GetProxy()`
33	`}`

func @406:46

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

406	`func(t any) T { return t.(T) }`

func @173:41

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/candy.go:

173	`func(s string) bool { return strings.EqualFold(s, col) }`

func .Model

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

316	`func (d dal[T, TS]) Model() T { return new(T) }`

func @40:41

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/tx.go:

func(tx *gorm.DB) error {
                return cb(SetCtxGormDB(ctx, &DB{
                        DB:                   &orm.DB{DB: tx},
                        Name:                 db.Name,
                        tableShardingPlugins: db.tableShardingPlugins,
                }))
        }

func @41:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/candy.go:

41	`func(o *scanOptionGeneric[T, TS]) {`
42	`o.dal = dal`
43	`}`

func @68:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/candy.go:

68	`func(o *scanOption) {`
69	`o.order = order`
70	`}`

func @401:82

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

401	`func(t *T) any { return t }`

func mysqlSoftDelete

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/construct.go:

178	`func mysqlSoftDelete(db orm.DB, conf Conf) {`
179	`callbacks.SoftDelete(db.GetProxy())`
180	`}`

func init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/construct.go:

182	`func init() {`
183	`config.AddComponent(config.ComponentDB, Construct)`
184	`}`

func GetCtxGormDB

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/ctx.go:

11	`func GetCtxGormDB(ctx context.Context) *DB {`
12	`return utils.GetCtxAny(ctx, fusCtx.KeyGormDB, (*DB)(nil))`
13	`}`

func ScanOrder

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/candy.go:

func ScanOrder(order any) utils.OptionFunc[scanOption] {
        return func(o *scanOption) {
                o.order = order
        }
}

func @46:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/db.go:

46	`func(o *useOption) {`
47	`o.appName = name`
48	`}`

func SetCtxGormDB

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/ctx.go:

23	`func SetCtxGormDB(ctx context.Context, db *DB) context.Context {`
24	`return utils.SetCtxAny(ctx, fusCtx.KeyGormDB, db)`
25	`}`

func Unscoped

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func Unscoped() utils.OptionFunc[mysqlDALOption] {
        return func(m *mysqlDALOption) {
                m.unscoped = true
        }
}

func @459:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

459	`func(m *mysqlDALOption) {`
460	`m.unscoped = true`
461	`}`

func .CanIgnore

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

324	`func (d *dal[T, TS]) CanIgnore(err error) bool { return errors.Is(err, gorm.ErrRecordNotFound) }`

func addInstance

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/construct.go:

func addInstance(ctx context.Context, name string, conf *Conf, opt *config.InitOption) {
        var logObj logger.Interface
        if !config.Use(opt.AppName).Debug() && utils.IsStrNotBlank(conf.LoggerConfig.Logger) {
                loggerType := inspect.TypeOf(conf.LoggerConfig.Logger)
                loggerValue := reflect.New(loggerType)
                if loggerValue.Type().Implements(customLoggerType) {
                        l := fusLog.Use(conf.LoggerConfig.LogInstance, fusLog.AppName(opt.AppName))
                        loggerValue.Interface().(customLogger).Init(l, opt.AppName, name)
                }
                logObj = loggerValue.Interface().(logger.Interface)
        }

        // conf.Option.Password = config.CryptoDecryptFunc()(conf.Option.Password)
        db, err := orm.Gorm.New(ctx, conf.Option, orm.WithLogger(logObj))
        if err != nil {
                panic(errors.Errorf("initialize gorm db instance error: %+v", err))
        }

        adaptMysqlAutoIncrementIncrement(db, conf)
        mysqlSoftDelete(db, conf)
        if config.Use(opt.AppName).Debug() {
                db.DB = db.Debug()
        }

        // sharding
        tablePluginMap := make(map[string]plugins.TableSharding, len(conf.Sharding))
        for _, shardConf := range conf.Sharding {
                var generator idgen.Generator
                if utils.IsStrNotBlank(shardConf.IDGen) {
                        generator = (*(*func() idgen.Generator)(inspect.FuncOf(shardConf.IDGen)))()
                }

                var expression gval.Evaluable
                if utils.IsStrNotBlank(shardConf.ShardingKeyExpr) {
                        expression = utils.Must(gval.Full().NewEvaluable(shardConf.ShardingKeyExpr))
                }

                tableShardingPlugin := plugins.DefaultTableSharding(plugins.TableShardingConfig{
                        Database:                 name,
                        Table:                    shardConf.Table,
                        ShardingKeys:             shardConf.Columns,
                        ShardingKeyExpr:          expression,
                        ShardingKeyByRawValue:    shardConf.ShardingKeyByRawValue,
                        ShardingKeysForMigrating: shardConf.ShardingKeysForMigrating,
                        NumberOfShards:           shardConf.NumberOfShards,
                        CustomSuffix:             shardConf.Suffix,
                        PrimaryKeyGenerator:      generator,
                })

                utils.MustSuccess(db.Use(tableShardingPlugin))
                tablePluginMap[shardConf.Table] = tableShardingPlugin
        }

        rwlock.Lock()
        defer rwlock.Unlock()
        if appInstances == nil {
                appInstances = make(map[string]map[string]*Instance)
        }
        if appInstances[opt.AppName] == nil {
                appInstances[opt.AppName] = make(map[string]*Instance)
        }
        if _, ok := appInstances[opt.AppName][name]; ok {
                panic(ErrDuplicatedName)
        }
        appInstances[opt.AppName][name] = &Instance{db: db, name: name, tableShardingPlugins: tablePluginMap}

        // ioc
        if opt.DI != nil {
                opt.DI.MustProvide(
                        func() *gorm.DB {
                                rwlock.RLock()
                                defer rwlock.RUnlock()
                                return appInstances[opt.AppName][name].GetProxy()
                        },
                        di.Name(name),
                )
        }

        go startDaemonRoutines(ctx, opt.AppName, name, conf)
}

func adaptMysqlAutoIncrementIncrement

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/construct.go:

func adaptMysqlAutoIncrementIncrement(db *orm.DB, conf *Conf) {
        autoIncrIncr := conf.AutoIncrementIncrement
        // unset, query auto increment increment
        if autoIncrIncr == 0 && conf.Driver == orm.DriverMysql {
                type autoConfig struct {
                        VariableName string `gorm:"column:Variable_name"`
                        Value        int64  `gorm:"column:Value"`
                }

                var cfg *autoConfig
                db.WithContext(context.Background()).
                        Raw("show variables like 'auto_increment_increment'").
                        Scan(&cfg)
                autoIncrIncr = cfg.Value
        }
        // no need to replace callbacks
        if autoIncrIncr <= 1 {
                return
        }

        callbacks.CreateAutoIncr(db.GetProxy(), db.GetDialector(), autoIncrIncr)
}

func .Delete

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func (d *dal[T, TS]) Delete(ctx context.Context, query any, args ...any) (int64, error) {
        o, args := d.parseOptionFromArgs(args...)
        ctx = context.WithValue(ctx, fusCtx.KeyDALOption, o)
        mList, ok := d.convertAnyToTS(query)
        if !ok || len(mList) == 0 {
                deleted := d.WriteDB(ctx).Clauses(o.clauses...).Where(query, args...).Delete(d.Model())
                return deleted.RowsAffected, deleted.Error
        } else {
                sharded, err := d.writeWithTableSharding(ctx, mList)
                if err != nil {
                        return 0, err
                }
                var rowAffected int64
                for _, mList := range sharded {
                        deleted := d.WriteDB(ctx).Clauses(o.clauses...).Delete(mList, args...)
                        if deleted.Error != nil {
                                return rowAffected, deleted.Error
                        }
                        rowAffected += deleted.RowsAffected
                }
                return rowAffected, nil
        }
}

func @45:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/construct.go:

func() {
                rwlock.Lock()
                defer rwlock.Unlock()

                pid := syscall.Getpid()
                app := config.Use(opt.AppName).AppName()
                if appInstances != nil {
                        for _, instance := range appInstances[opt.AppName] {
                                if sqlDB, err := instance.GetProxy().DB(); err == nil {
                                        if err := sqlDB.Close(); err != nil {
                                                log.Printf("%v [Gofusion] %s %s close error: %s", pid, app, config.ComponentDB, err)
                                        }
                                }
                        }
                        delete(appInstances, opt.AppName)
                }
                if len(appInstances) == 0 {
                        for _, patch := range patches {
                                if patch != nil {
                                        patch.Reset()
                                }
                        }
                        softdelete.PatchGormDeleteAtOnce = new(sync.Once)
                }
        }

func .ShardingIDGen

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func (d *dal[T, TS]) ShardingIDGen(ctx context.Context) (id uint64, err error) {
        writeDB := d.writeDB(ctx)
        tableName := d.tableName(writeDB, new(T))
        tableShardingPlugin, ok := writeDB.tableShardingPlugins[tableName]
        if !ok {
                return 0, plugins.ErrIDGeneratorNotFound
        }
        return tableShardingPlugin.ShardingIDGen(ctx)
}

func Use

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/db.go:

func Use(ctx context.Context, name string, opts ...utils.OptionExtender) *DB {
        opt := utils.ApplyOptions[useOption](opts...)

        rwlock.RLock()
        defer rwlock.RUnlock()
        instances, ok := appInstances[opt.appName]
        if !ok {
                panic(errors.Errorf("db instance not found for app: %s", opt.appName))
        }
        instance, ok := instances[name]
        if !ok {
                panic(errors.Errorf("db instance not found for name: %s", name))
        }

        return &DB{DB: instance.db.WithContext(ctx), Name: name, tableShardingPlugins: instance.tableShardingPlugins}
}

func .parseOptionFromArgs

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func (d *dal[T, TS]) parseOptionFromArgs(args ...any) (o *mysqlDALOption, r []any) {
        o = new(mysqlDALOption)
        r = make([]any, 0, len(args))
        for _, arg := range args {
                if reflect.TypeOf(arg).Implements(gormClauseExpressionType) {
                        o.clauses = append(o.clauses, arg.(clause.Expression))
                        continue
                }

                switch v := arg.(type) {
                case utils.OptionFunc[mysqlDALOption]:
                        v(o)
                default:
                        r = append(r, arg)
                }
        }
        return
}

func NewDAL

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func NewDAL[T any, TS ~[]*T](readDBName, writeDBName string, opts ...utils.OptionExtender) DalInterface[T, TS] {
        instance := new(T)
        if _, ok := any(instance).(schema.Tabler); !ok {
                panic(errors.Errorf("model unimplement schema.Tabler [model[%T] read_db[%s] write_db[%s]]",
                        instance, readDBName, writeDBName))
        }
        opt := utils.ApplyOptions[useOption](opts...)
        return &dal[T, TS]{
                appName:     opt.appName,
                readDBName:  readDBName,
                writeDBName: writeDBName,
        }
}

func .InsertInBatches

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func (d *dal[T, TS]) InsertInBatches(ctx context.Context,
        modList TS, batchSize int, opts ...utils.OptionExtender) error {
        o := utils.ApplyOptions[mysqlDALOption](opts...)
        ctx = context.WithValue(ctx, fusCtx.KeyDALOption, o)
        sharded, err := d.writeWithTableSharding(ctx, modList)
        if err != nil {
                return err
        }
        for _, mList := range sharded {
                if err = d.WriteDB(ctx).Clauses(o.clauses...).CreateInBatches(mList, batchSize).Error; err != nil {
                        return err
                }
        }

        return nil
}

func WithinTx

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/tx.go:

func WithinTx(ctx context.Context, cb func(ctx context.Context) (err error), opts ...utils.OptionExtender) error {
        var db *DB

        o := utils.ApplyOptions[useOption](opts...)
        opt := utils.ApplyOptions[txOption](opts...)
        if opt.dbName == "" {
                db = GetCtxGormDB(ctx)
        } else {
                utils.IfAny(
                        func() bool { db = GetCtxGormDBByName(ctx, opt.dbName); return db != nil },
                        func() bool { db = Use(ctx, opt.dbName, AppName(o.appName)); return db != nil },
                )
        }
        if db == nil {
                panic(ErrDatabaseNotFound)
        }

        return db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
                return cb(SetCtxGormDB(ctx, &DB{
                        DB:                   &orm.DB{DB: tx},
                        Name:                 db.Name,
                        tableShardingPlugins: db.tableShardingPlugins,
                }))
        })
}

func .tableName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func (d *dal[T, TS]) tableName(db *DB, mod *T) (name string) {
        if tabler, ok := any(mod).(schema.Tabler); ok {
                name = tabler.TableName()
        }
        if tabler, ok := any(mod).(schema.TablerWithNamer); ok {
                name = tabler.TableName(db.NamingStrategy)
        }
        // TODO: check if embeddedNamer valid
        embeddedNamer := inspect.TypeOf("gorm.io/gorm/schema.embeddedNamer")
        namingStrategy := reflect.ValueOf(db.NamingStrategy)
        if namingStrategy.CanConvert(embeddedNamer) {
                name = namingStrategy.Convert(embeddedNamer).FieldByName("Table").String()
        }
        return
}

func .writeWithTableSharding

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func (d *dal[T, TS]) writeWithTableSharding(ctx context.Context, src TS) (dst []TS, err error) {
        if len(src) == 0 {
                return
        }
        writeDB := d.writeDB(ctx)
        shardingPlugin, ok := writeDB.tableShardingPlugins[d.tableName(writeDB, src[0])]
        if !ok {
                return []TS{src}, nil
        }

        sharded, err := shardingPlugin.ShardingByModelList(ctx, utils.SliceMapping(src, func(t *T) any { return t })...)
        if err != nil {
                return
        }
        for _, item := range sharded {
                dst = append(dst, utils.SliceMapping(item, func(t any) *T { return t.(*T) }))
        }
        return
}

func .WriteDB

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func (d *dal[T, TS]) WriteDB(ctx context.Context) *gorm.DB {
        o, _ := ctx.Value(fusCtx.KeyDALOption).(*mysqlDALOption)
        if orm := GetCtxGormDB(ctx); orm != nil && orm.Name == d.writeDBName {
                return d.unscopedGormDB(orm.Model(d.Model()), o)
        }

        return d.unscopedGormDB(Use(ctx, d.writeDBName, AppName(d.appName)).WithContext(ctx).Model(d.Model()), o)
}

func @116:21

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/metrics.go:

func() {
                rwlock.RLock()
                defer rwlock.RUnlock()
                instances, ok := appInstances[appName]
                if !ok {
                        return
                }
                instance, ok := instances[name]
                if !ok {
                        return
                }
                db := instance.GetProxy()
                sqlDB, err := db.DB()
                if err != nil {
                        return
                }

                begin := time.Now()
                if err := sqlDB.Ping(); err != nil {
                        return
                }
                latency := float64(time.Since(begin)) / float64(time.Millisecond)
                latencyKey := append([]string{config.Use(appName).AppName()}, metricsLatencyKey...)
                for _, m := range metrics.Internal(metrics.AppName(appName)) {
                        select {
                        case <-ctx.Done():
                                return
                        default:
                                if m.IsEnableServiceLabel() {
                                        m.AddSample(ctx, latencyKey, latency,
                                                metrics.Labels(labels),
                                                metrics.PrometheusBuckets(metricsLatencyBuckets),
                                        )
                                } else {
                                        m.AddSample(ctx, metricsLatencyKey, latency,
                                                metrics.Labels(labels),
                                                metrics.PrometheusBuckets(metricsLatencyBuckets),
                                        )
                                }
                        }
                }
        }

func @58:21

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/metrics.go:

func() {
                rwlock.RLock()
                defer rwlock.RUnlock()

                instances, ok := appInstances[appName]
                if !ok {
                        return
                }
                instance, ok := instances[name]
                if !ok {
                        return
                }
                db := instance.GetProxy()
                sqlDB, err := db.DB()
                if err != nil {
                        return
                }

                app := config.Use(appName).AppName()
                idleKey := append([]string{app}, metricsPoolIdleKey...)
                inuseKey := append([]string{app}, metricsPoolInUseKey...)
                totalKey := append([]string{app}, metricsPoolTotalKey...)
                waitCountKey := append([]string{app}, metricsPoolWaitCountKey...)
                waitDurationKey := append([]string{app}, metricsPoolWaitDurationKey...)

                stats := sqlDB.Stats()
                waitDuration := float64(stats.WaitDuration) / float64(time.Millisecond)
                for _, m := range metrics.Internal(metrics.AppName(appName)) {
                        select {
                        case <-ctx.Done():
                                return
                        default:
                                if m.IsEnableServiceLabel() {
                                        m.SetGauge(ctx, idleKey, float64(stats.Idle), metrics.Labels(labels))
                                        m.SetGauge(ctx, inuseKey, float64(stats.InUse), metrics.Labels(labels))
                                        m.SetGauge(ctx, totalKey, float64(stats.OpenConnections), metrics.Labels(labels))
                                        m.SetGauge(ctx, waitCountKey, float64(stats.WaitCount), metrics.Labels(labels))
                                        m.SetGauge(ctx, waitDurationKey, waitDuration, metrics.Labels(labels))
                                } else {
                                        m.SetGauge(ctx, metricsPoolIdleKey, float64(stats.Idle), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsPoolInUseKey, float64(stats.InUse), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsPoolTotalKey, float64(stats.OpenConnections), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsPoolWaitCountKey, float64(stats.WaitCount), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsPoolWaitDurationKey, waitDuration, metrics.Labels(labels))
                                }
                        }
                }
        }

func .Save

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func (d *dal[T, TS]) Save(ctx context.Context, mod any, opts ...utils.OptionExtender) error {
        // Translate the struct to slice to follow the insert into with ON DUPLICATE KEY UPDATE
        mList, ok := d.convertAnyToTS(mod)
        if !ok {
                mList = utils.SliceConvert(mod, reflect.TypeOf(TS{})).(TS)
        }
        if len(mList) == 0 {
                return nil
        }
        o := utils.ApplyOptions[mysqlDALOption](opts...)
        ctx = context.WithValue(ctx, fusCtx.KeyDALOption, o)
        sharded, err := d.writeWithTableSharding(ctx, mList)
        if err != nil {
                return err
        }
        for _, mList := range sharded {
                if err = d.WriteDB(ctx).Clauses(o.clauses...).Save(mList).Error; err != nil {
                        return err
                }
        }

        return nil
}

func .ReadDB

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func (d *dal[T, TS]) ReadDB(ctx context.Context) *gorm.DB {
        o, _ := ctx.Value(fusCtx.KeyDALOption).(*mysqlDALOption)
        if orm := GetCtxGormDB(ctx); orm != nil && orm.Name == d.readDBName {
                return d.unscopedGormDB(orm.Model(d.Model()), o)
        }

        dbName := d.readDBName
        if o != nil && o.useWriteDB {
                dbName = d.writeDBName
        }
        return d.unscopedGormDB(Use(ctx, dbName, AppName(d.appName)).WithContext(ctx).Model(d.Model()), o)
}

func Business.BeforeCreate

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/model.go:

func (b *Business) BeforeCreate(tx *gorm.DB) (err error) {
        if b == nil {
                tx.Statement.SetColumn("uuid", utils.UUID())
                return
        }
        if b.UUID == [16]byte{0} {
                b.UUID = uuid.New()
        }
        return
}

func metricDBStats

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/metrics.go:

func metricDBStats(ctx context.Context, appName, name string, labels []metrics.Label) {
        select {
        case <-ctx.Done():
                return
        default:

        }

        _, _ = utils.Catch(func() {
                rwlock.RLock()
                defer rwlock.RUnlock()

                instances, ok := appInstances[appName]
                if !ok {
                        return
                }
                instance, ok := instances[name]
                if !ok {
                        return
                }
                db := instance.GetProxy()
                sqlDB, err := db.DB()
                if err != nil {
                        return
                }

                app := config.Use(appName).AppName()
                idleKey := append([]string{app}, metricsPoolIdleKey...)
                inuseKey := append([]string{app}, metricsPoolInUseKey...)
                totalKey := append([]string{app}, metricsPoolTotalKey...)
                waitCountKey := append([]string{app}, metricsPoolWaitCountKey...)
                waitDurationKey := append([]string{app}, metricsPoolWaitDurationKey...)

                stats := sqlDB.Stats()
                waitDuration := float64(stats.WaitDuration) / float64(time.Millisecond)
                for _, m := range metrics.Internal(metrics.AppName(appName)) {
                        select {
                        case <-ctx.Done():
                                return
                        default:
                                if m.IsEnableServiceLabel() {
                                        m.SetGauge(ctx, idleKey, float64(stats.Idle), metrics.Labels(labels))
                                        m.SetGauge(ctx, inuseKey, float64(stats.InUse), metrics.Labels(labels))
                                        m.SetGauge(ctx, totalKey, float64(stats.OpenConnections), metrics.Labels(labels))
                                        m.SetGauge(ctx, waitCountKey, float64(stats.WaitCount), metrics.Labels(labels))
                                        m.SetGauge(ctx, waitDurationKey, waitDuration, metrics.Labels(labels))
                                } else {
                                        m.SetGauge(ctx, metricsPoolIdleKey, float64(stats.Idle), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsPoolInUseKey, float64(stats.InUse), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsPoolTotalKey, float64(stats.OpenConnections), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsPoolWaitCountKey, float64(stats.WaitCount), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsPoolWaitDurationKey, waitDuration, metrics.Labels(labels))
                                }
                        }
                }
        })
}

func .writeDB

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func (d *dal[T, TS]) writeDB(ctx context.Context) *DB {
        if orm := GetCtxGormDB(ctx); orm != nil && orm.Name == d.writeDBName {
                return orm
        }

        return Use(ctx, d.writeDBName, AppName(d.appName))
}

func metricDBLatency

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/metrics.go:

func metricDBLatency(ctx context.Context, appName, name string, labels []metrics.Label) {
        select {
        case <-ctx.Done():
                return
        default:

        }

        _, _ = utils.Catch(func() {
                rwlock.RLock()
                defer rwlock.RUnlock()
                instances, ok := appInstances[appName]
                if !ok {
                        return
                }
                instance, ok := instances[name]
                if !ok {
                        return
                }
                db := instance.GetProxy()
                sqlDB, err := db.DB()
                if err != nil {
                        return
                }

                begin := time.Now()
                if err := sqlDB.Ping(); err != nil {
                        return
                }
                latency := float64(time.Since(begin)) / float64(time.Millisecond)
                latencyKey := append([]string{config.Use(appName).AppName()}, metricsLatencyKey...)
                for _, m := range metrics.Internal(metrics.AppName(appName)) {
                        select {
                        case <-ctx.Done():
                                return
                        default:
                                if m.IsEnableServiceLabel() {
                                        m.AddSample(ctx, latencyKey, latency,
                                                metrics.Labels(labels),
                                                metrics.PrometheusBuckets(metricsLatencyBuckets),
                                        )
                                } else {
                                        m.AddSample(ctx, metricsLatencyKey, latency,
                                                metrics.Labels(labels),
                                                metrics.PrometheusBuckets(metricsLatencyBuckets),
                                        )
                                }
                        }
                }
        })
}

func .IgnoreErr

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func (d *dal[T, TS]) IgnoreErr(err error) error {
        if errors.Is(err, gorm.ErrRecordNotFound) {
                return nil
        }
        return err
}

func Scan

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/candy.go:

func Scan[T any, TS ~[]*T](ctx context.Context, cb func(TS) bool, opts ...utils.OptionExtender) (err error) {
        var (
                tx    *gorm.DB
                mList TS
        )

        o := utils.ApplyOptions[useOption](opts...)
        opt := utils.ApplyOptions[scanOption](opts...)
        optG := utils.ApplyOptions[scanOptionGeneric[T, TS]](opts...)

        // get db instance
        switch {
        case optG.dal != nil:
                tx = optG.dal.ReadDB(ctx)
        case opt.dbName != "":
                tx = Use(ctx, opt.dbName, AppName(o.appName)).GetProxy()
        default:
                panic(errors.New("unknown which table to scan"))
        }

        // default values
        if opt.cursors == nil {
                opt.cursors = []any{0}
        }
        if opt.cursorWhere == nil {
                opt.cursorWhere = "id > ?"
        }
        if len(opt.cursorColumns) == 0 {
                opt.cursorColumns = []string{"id"}
        }
        if opt.order == nil {
                opt.order = fmt.Sprintf("%s ASC", strings.Join(opt.cursorColumns, constant.Comma))
        }
        if opt.batch == 0 {
                opt.batch = 100
        }
        if opt.limit == 0 {
                opt.limit = math.MaxInt
        }

        count := 0
        tx = tx.WithContext(ctx)
        if opt.log != nil {
                opt.log.Info(ctx, "scan begin [where[%s][%+v] cursor[%s][%+v] order[%s] limit[%v] batch[%v]]",
                        opt.where, opt.sqlAndArguments, opt.cursorWhere, opt.cursors, opt.order, opt.limit, opt.batch)

                defer func() { opt.log.Info(ctx, "scan end [count[%v]]", count) }()
        }

        // scan
        for hasMore := true; hasMore; hasMore = len(mList) >= opt.batch {
                // init model slice
                mList = make(TS, 0, opt.batch)

                // db query
                q := tx.Where(opt.cursorWhere, opt.cursors...)
                if opt.where != nil {
                        q = q.Where(opt.where, opt.sqlAndArguments...)
                }
                if opt.order != nil {
                        q = q.Order(opt.order)
                }
                if err = q.Limit(opt.batch).Find(&mList).Error; err != nil {
                        if opt.log != nil {
                                opt.log.Warn(ctx, "scan quit because meet with error [err[%s]]", err)
                        }
                        break
                }

                if len(mList) > 0 {
                        // callback
                        if !cb(mList) {
                                if opt.log != nil {
                                        opt.log.Info(ctx, "scan quit because callback return false")
                                }
                                break
                        }

                        // get next cursor
                        next := mList[len(mList)-1]
                        nextVal := reflect.Indirect(reflect.ValueOf(next))
                        for idx, col := range opt.cursorColumns {
                                fieldVal := nextVal.FieldByNameFunc(func(s string) bool { return strings.EqualFold(s, col) })
                                if !fieldVal.IsValid() {
                                        fieldVal, _ = utils.GetGormColumnValue(next, col)
                                }
                                if !fieldVal.IsValid() {
                                        err = errors.Errorf("scan cursor column value is not found [col[%s]]", col)
                                        if opt.log != nil {
                                                opt.log.Error(ctx, "%s", err)
                                        }
                                        return
                                }
                                opt.cursors[idx] = fieldVal.Interface()
                        }
                }

                // check if exceed max
                if count += len(mList); count >= opt.limit {
                        if opt.log != nil {
                                opt.log.Info(ctx, "scan quit because reach max [count[%v] max[%v]]", count, opt.limit)
                        }
                        break
                }
        }

        return
}

func BusinessSoftDeleted.BeforeCreate

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/model.go:

func (b *BusinessSoftDeleted) BeforeCreate(tx *gorm.DB) (err error) {
        if b == nil {
                tx.Statement.SetColumn("uuid", utils.UUID())
                tx.Statement.SetColumn("delete_time", nil)
                return
        }
        if b.UUID == [16]byte{0} {
                b.UUID = uuid.New()
        }
        return
}

func .convertAnyToTS

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func (d *dal[T, TS]) convertAnyToTS(query any) (mList TS, ok bool) {
        switch q := query.(type) {
        case TS:
                ok = true
                mList = q
        case []*T:
                ok = true
                mList = TS(q)
        case []T:
                ok = true
                mList = TS(utils.SliceMapping(q, func(t T) *T { return &t }))
        case T:
                ok = true
                mList = TS{&q}
        case *T:
                ok = true
                mList = TS{q}
        }
        return
}

func @206:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/model.go:

func() (err error) {
                if tx.Error != nil {
                        return
                }

                var bs []byte
                switch v := field.(type) {
                case string:
                        bs = []byte(v)
                case *string:
                        if v == nil {
                                return
                        }
                        bs = []byte(*v)
                case []byte:
                        bs = v
                case *[]byte:
                        if v == nil {
                                return
                        }
                        bs = *v
                default:
                        return tx.AddError(errors.New("unsupported unmarshal field type"))
                }
                // be compatible with empty value
                if len(bs) == 0 {
                        bs = []byte("null")
                }

                return tx.AddError(json.Unmarshal(bs, &obj))
        }

func @239:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/model.go:

func() (err error) {
                if tx.Error != nil {
                        return
                }

                switch v := field.(type) {
                case **string, **[]byte, *string, *[]byte:
                        if v == nil {
                                return
                        }
                        bs, err := json.Marshal(obj)
                        if err != nil {
                                return tx.AddError(errors.Wrap(err, "gorm json marshal error"))
                        }
                        switch f := field.(type) {
                        case *string:
                                *f = string(bs)
                        case **string:
                                *f = utils.AnyPtr(string(bs))
                        case *[]byte:
                                *f = bs
                        case **[]byte:
                                *f = utils.AnyPtr(bs)
                        }
                default:
                        return tx.AddError(errors.New("unsupported marshal field type"))
                }
                return
        }

func .ShardingByModelList

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func (d *dal[T, TS]) ShardingByModelList(ctx context.Context, src TS) (dst map[string]TS, err error) {
        if len(src) == 0 {
                return make(map[string]TS), nil
        }
        writeDB := d.writeDB(ctx)
        tableName := d.tableName(writeDB, src[0])
        shardingPlugin, ok := writeDB.tableShardingPlugins[tableName]
        if !ok {
                return map[string]TS{tableName: src}, nil
        }
        sharded, err := shardingPlugin.ShardingByModelList(ctx, utils.SliceMapping(src, func(t *T) any { return t })...)
        if err != nil {
                return
        }
        dst = make(map[string]TS, len(sharded))
        for suffix, item := range sharded {
                shardingTableName := tableName + suffix
                dst[shardingTableName] = TS(utils.SliceMapping(item, func(t any) *T { return t.(*T) }))
        }
        return
}

func .ShardingIDListGen

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func (d *dal[T, TS]) ShardingIDListGen(ctx context.Context, amount int) (idList []uint64, err error) {
        writeDB := d.writeDB(ctx)
        tableName := d.tableName(writeDB, new(T))
        tableShardingPlugin, ok := writeDB.tableShardingPlugins[tableName]
        if !ok {
                return nil, plugins.ErrIDGeneratorNotFound
        }
        idList = make([]uint64, 0, amount)
        for i := 0; i < amount; i++ {
                id, err := tableShardingPlugin.ShardingIDGen(ctx)
                if err != nil {
                        return nil, err
                }
                idList = append(idList, id)
        }
        return
}

func .QueryInBatches

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func (d *dal[T, TS]) QueryInBatches(ctx context.Context, batchSize int,
        fc func(tx *DB, batch int, found TS) error, query any, args ...any) (err error) {
        o, args := d.parseOptionFromArgs(args...)
        ctx = context.WithValue(ctx, fusCtx.KeyDALOption, o)

        orm := Use(ctx, d.readDBName, AppName(d.appName))
        found := make(TS, 0, batchSize)
        result := d.ReadDB(ctx).Clauses(o.clauses...).Where(query, args...).FindInBatches(&found, batchSize,
                func(tx *gorm.DB, batch int) error {
                        wrapper := &DB{
                                DB:                   &ormDrv.DB{DB: tx},
                                Name:                 orm.Name,
                                tableShardingPlugins: orm.tableShardingPlugins,
                        }
                        return fc(wrapper, batch, found)
                },
        )
        if d.CanIgnore(result.Error) {
                return
        }
        return d.IgnoreErr(result.Error)
}

func .Query

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func (d *dal[T, TS]) Query(ctx context.Context, query any, args ...any) (TS, error) {
        o, args := d.parseOptionFromArgs(args...)
        ctx = context.WithValue(ctx, fusCtx.KeyDALOption, o)

        found := d.ModelSlice()
        result := d.ReadDB(ctx).Clauses(o.clauses...).Where(query, args...).Find(&found)
        if d.CanIgnore(result.Error) {
                return nil, nil
        }
        return found, d.IgnoreErr(result.Error)
}

func .Count

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func (d *dal[T, TS]) Count(ctx context.Context, query any, args ...any) (int64, error) {
        var count int64

        o, args := d.parseOptionFromArgs(args...)
        ctx = context.WithValue(ctx, fusCtx.KeyDALOption, o)

        result := d.ReadDB(ctx).Clauses(o.clauses...).Where(query, args...).Count(&count)
        if d.CanIgnore(result.Error) {
                return 0, nil
        }
        return count, d.IgnoreErr(result.Error)
}

func .QueryLast

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func (d *dal[T, TS]) QueryLast(ctx context.Context, query any, args ...any) (*T, error) {
        o, args := d.parseOptionFromArgs(args...)
        ctx = context.WithValue(ctx, fusCtx.KeyDALOption, o)

        found := d.Model()
        result := d.ReadDB(ctx).Clauses(o.clauses...).Where(query, args...).Last(found)
        if d.CanIgnore(result.Error) {
                return nil, nil
        }
        return found, d.IgnoreErr(result.Error)
}

func .Transaction

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func (d *dal[T, TS]) Transaction(ctx context.Context, fc func(context.Context) error,
        opts ...utils.OptionExtender) error {
        orm := GetCtxGormDB(ctx)
        o := utils.ApplyOptions[mysqlDALOption](opts...)
        if orm == nil || (orm.Name != d.writeDBName && orm.Name != d.readDBName) {
                if o.useWriteDB {
                        orm = Use(ctx, d.writeDBName, AppName(d.appName))
                } else {
                        orm = Use(ctx, d.readDBName, AppName(d.appName))
                }
        }

        return d.unscopedGormDB(orm.GetProxy().WithContext(ctx), o).Transaction(func(tx *gorm.DB) error {
                return fc(SetCtxGormDB(ctx, &DB{
                        DB:                   &ormDrv.DB{DB: tx},
                        Name:                 orm.Name,
                        tableShardingPlugins: orm.tableShardingPlugins,
                }))
        })
}

func .ShardingByValues

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func (d *dal[T, TS]) ShardingByValues(ctx context.Context, src []map[string]any) (
        dst map[string][]map[string]any, err error) {
        writeDB := d.writeDB(ctx)
        tableName := d.tableName(writeDB, new(T))
        tableShardingPlugin, ok := writeDB.tableShardingPlugins[tableName]
        if !ok {
                return map[string][]map[string]any{tableName: src}, nil
        }
        return tableShardingPlugin.ShardingByValues(ctx, src)
}

func Data.Equals

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/model.go:

func (d *Data) Equals(o *Data) bool {
        if d == nil && o == nil {
                return true
        }
        if d == nil || o == nil {
                return false
        }
        return d.ID == o.ID &&
                d.CreateTimeMs == o.CreateTimeMs &&
                d.ModifyTimeMs == o.ModifyTimeMs
}

func Business.Equals

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/model.go:

func (b *Business) Equals(o *Business) bool {
        if b == nil && o == nil {
                return true
        }
        if b == nil || o == nil {
                return false
        }
        return b.Data.Equals(&o.Data) &&
                b.UUID == o.UUID &&
                b.BizCreateTimeMs == o.BizCreateTimeMs &&
                b.BizModifyTimeMs == o.BizModifyTimeMs
}

func BusinessSoftDeleted.Equals

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/model.go:

func (b *BusinessSoftDeleted) Equals(o *BusinessSoftDeleted) bool {
        if b == nil && o == nil {
                return true
        }
        if b == nil || o == nil {
                return false
        }
        return b.DataSoftDeleted.Equals(&o.DataSoftDeleted) &&
                b.UUID == o.UUID &&
                b.BizCreateTimeMs == o.BizCreateTimeMs &&
                b.BizModifyTimeMs == o.BizModifyTimeMs
}

func DataSoftDeleted.Equals

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/model.go:

func (d *DataSoftDeleted) Equals(o *DataSoftDeleted) bool {
        if d == nil && o == nil {
                return true
        }
        if d == nil || o == nil {
                return false
        }
        return d.ID == o.ID &&
                d.CreateTimeMs == o.CreateTimeMs &&
                d.ModifyTimeMs == o.ModifyTimeMs &&
                d.DeleteTimeMs == o.DeleteTimeMs &&
                d.Deleted == o.Deleted
}

func .Take

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func (d *dal[T, TS]) Take(ctx context.Context, dest any, conds ...any) error {
        o, args := d.parseOptionFromArgs(conds...)
        ctx = context.WithValue(ctx, fusCtx.KeyDALOption, o)

        result := d.ReadDB(ctx).Clauses(o.clauses...).Take(dest, args...)
        return d.IgnoreErr(result.Error)
}

func .Pluck

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func (d *dal[T, TS]) Pluck(ctx context.Context, column string, dest any,
        query any, args ...any) error {
        o, args := d.parseOptionFromArgs(args...)
        ctx = context.WithValue(ctx, fusCtx.KeyDALOption, o)

        result := d.ReadDB(ctx).Clauses(o.clauses...).Where(query, args...).Pluck(column, dest)
        return d.IgnoreErr(result.Error)
}

func .Updates

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func (d *dal[T, TS]) Updates(ctx context.Context, columns map[string]any,
        query any, args ...any) (int64, error) {
        o, args := d.parseOptionFromArgs(args...)
        ctx = context.WithValue(ctx, fusCtx.KeyDALOption, o)
        u := d.WriteDB(ctx).Clauses(o.clauses...).Where(query, args...).Updates(columns)
        return u.RowsAffected, u.Error
}

func .Update

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func (d *dal[T, TS]) Update(ctx context.Context, column string, value any,
        query any, args ...any) (int64, error) {
        o, args := d.parseOptionFromArgs(args...)
        ctx = context.WithValue(ctx, fusCtx.KeyDALOption, o)
        u := d.WriteDB(ctx).Clauses(o.clauses...).Where(query, args...).Update(column, value)
        return u.RowsAffected, u.Error
}

func .FirstOrCreate

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func (d *dal[T, TS]) FirstOrCreate(ctx context.Context, mod *T, conds ...any) (int64, error) {
        o, conds := d.parseOptionFromArgs(conds...)
        ctx = context.WithValue(ctx, fusCtx.KeyDALOption, o)
        result := d.WriteDB(ctx).Clauses(o.clauses...).FirstOrCreate(mod, conds...)
        return result.RowsAffected, result.Error
}

func .SetCtxWriteDB

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func (d *dal[T, TS]) SetCtxWriteDB(src context.Context) (dst context.Context) {
        if orm := GetCtxGormDB(src); orm != nil && orm.Name == d.writeDBName {
                return src
        }
        return SetCtxGormDB(src, Use(src, d.writeDBName, AppName(d.appName)))
}

func .SetCtxReadDB

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func (d *dal[T, TS]) SetCtxReadDB(src context.Context) (dst context.Context) {
        if orm := GetCtxGormDB(src); orm != nil && orm.Name == d.readDBName {
                return src
        }

        return SetCtxGormDB(src, Use(src, d.readDBName, AppName(d.appName)))
}

func DataSoftDeleted.DeleteTime

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/model.go:

func (d *DataSoftDeleted) DeleteTime() *time.Time {
        if !d.DeleteTimeMs.Valid {
                return nil
        }
        return utils.AnyPtr(utils.GetTime(d.DeleteTimeMs.Int64))
}

func BusinessSoftDeleted.Clone

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/model.go:

func (b *BusinessSoftDeleted) Clone() *BusinessSoftDeleted {
        if b == nil {
                return nil
        }
        return &BusinessSoftDeleted{
                DataSoftDeleted: *b.DataSoftDeleted.Clone(),
                UUID:            b.UUID,
                BizCreateTimeMs: b.BizCreateTimeMs,
                BizModifyTimeMs: b.BizModifyTimeMs,
        }
}

func Data.Clone

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/model.go:

func (d *Data) Clone() *Data {
        if d == nil {
                return nil
        }
        return &Data{
                ID:           d.ID,
                CreateTimeMs: d.CreateTimeMs,
                ModifyTimeMs: d.ModifyTimeMs,
        }
}

func Business.Clone

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/model.go:

func (b *Business) Clone() *Business {
        if b == nil {
                return nil
        }
        return &Business{
                Data:            *b.Data.Clone(),
                UUID:            b.UUID,
                BizCreateTimeMs: b.BizCreateTimeMs,
                BizModifyTimeMs: b.BizModifyTimeMs,
        }
}

func @141:4

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/construct.go:

func() *gorm.DB {
                                rwlock.RLock()
                                defer rwlock.RUnlock()
                                return appInstances[opt.AppName][name].GetProxy()
                        }

func DataSoftDeleted.Clone

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/model.go:

func (d *DataSoftDeleted) Clone() *DataSoftDeleted {
        if d == nil {
                return nil
        }
        return &DataSoftDeleted{
                ID:           d.ID,
                Deleted:      d.Deleted,
                CreateTimeMs: d.CreateTimeMs,
                ModifyTimeMs: d.ModifyTimeMs,
                DeleteTimeMs: d.DeleteTimeMs,
        }
}

func @53:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/candy.go:

53	`func(o *scanOption) {`
54	`o.where = where`
55	`o.sqlAndArguments = sqlAndArguments`
56	`}`

func @116:3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func(tx *gorm.DB, batch int) error {
                        wrapper := &DB{
                                DB:                   &ormDrv.DB{DB: tx},
                                Name:                 orm.Name,
                                tableShardingPlugins: orm.tableShardingPlugins,
                        }
                        return fc(wrapper, batch, found)
                }

func @33:4

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/tx.go:

33	`func() bool { db = Use(ctx, opt.dbName, AppName(o.appName)); return db != nil }`

func @372:82

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

372	`func(t *T) any { return t }`

func Data.ModifyTime

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/model.go:

24	`func (d *Data) ModifyTime() time.Time {`
25	`return utils.GetTime(d.ModifyTimeMs)`
26	`}`

func DataSoftDeleted.CreateTime

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/model.go:

59	`func (d *DataSoftDeleted) CreateTime() time.Time {`
60	`return utils.GetTime(d.CreateTimeMs)`
61	`}`

func DataSoftDeleted.ModifyTime

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/model.go:

62	`func (d *DataSoftDeleted) ModifyTime() time.Time {`
63	`return utils.GetTime(d.ModifyTimeMs)`
64	`}`

func Data.CreateTime

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/model.go:

21	`func (d *Data) CreateTime() time.Time {`
22	`return utils.GetTime(d.CreateTimeMs)`
23	`}`

func @471:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

471	`func(m *mysqlDALOption) {`
472	`m.useWriteDB = true`
473	`}`

func WriteDB

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func WriteDB() utils.OptionFunc[mysqlDALOption] {
        return func(m *mysqlDALOption) {
                m.useWriteDB = true
        }
}

func @465:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

465	`func(m *mysqlDALOption) {`
466	`m.clauses = append(m.clauses, clauses...)`
467	`}`

func Business.BeforeCreateFn

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/model.go:

func (b *Business) BeforeCreateFn(tx *gorm.DB) func() error {
        return func() (err error) {
                return b.BeforeCreate(tx)
        }
}

func @116:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/model.go:

116	`func() (err error) {`
117	`return b.BeforeCreate(tx)`
118	`}`

func Business.BizCreateTime

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/model.go:

120	`func (b *Business) BizCreateTime() time.Time {`
121	`return utils.GetTime(b.BizCreateTimeMs)`
122	`}`

func Business.BizModifyTime

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/model.go:

123	`func (b *Business) BizModifyTime() time.Time {`
124	`return utils.GetTime(b.BizModifyTimeMs)`
125	`}`

func Clauses

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func Clauses(clauses ...clause.Expression) utils.OptionFunc[mysqlDALOption] {
        return func(m *mysqlDALOption) {
                m.clauses = append(m.clauses, clauses...)
        }
}

func @435:36

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

435	`func(t T) *T { return &t }`

func @379:56

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

379	`func(t any) T { return t.(T) }`

func BusinessSoftDeleted.BeforeCreateFn

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/model.go:

func (b *BusinessSoftDeleted) BeforeCreateFn(tx *gorm.DB) func() error {
        return func() (err error) {
                return b.BeforeCreate(tx)
        }
}

func @170:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/model.go:

170	`func() (err error) {`
171	`return b.BeforeCreate(tx)`
172	`}`

func .ModelSlice

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

317	`func (d *dal[T, TS]) ModelSlice() TS { return make(TS, 0) }`

func BusinessSoftDeleted.BizModifyTime

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/model.go:

177	`func (b *BusinessSoftDeleted) BizModifyTime() time.Time {`
178	`return utils.GetTime(b.BizModifyTimeMs)`
179	`}`

func @273:74

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/dal.go:

func(tx *gorm.DB) error {
                return fc(SetCtxGormDB(ctx, &DB{
                        DB:                   &ormDrv.DB{DB: tx},
                        Name:                 orm.Name,
                        tableShardingPlugins: orm.tableShardingPlugins,
                }))
        }

func @86:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/candy.go:

86	`func(o *scanOption) {`
87	`o.log = log`
88	`}`

func CheckGormErrorFn

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/model.go:

204	`func CheckGormErrorFn(tx *gorm.DB) func() error { return func() error { return tx.Error } }`

func @204:58

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/model.go:

204	`func() error { return tx.Error }`

func JsonUnmarshalFn

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/model.go:

func JsonUnmarshalFn(tx *gorm.DB, obj, field any) func() error {
        return func() (err error) {
                if tx.Error != nil {
                        return
                }

                var bs []byte
                switch v := field.(type) {
                case string:
                        bs = []byte(v)
                case *string:
                        if v == nil {
                                return
                        }
                        bs = []byte(*v)
                case []byte:
                        bs = v
                case *[]byte:
                        if v == nil {
                                return
                        }
                        bs = *v
                default:
                        return tx.AddError(errors.New("unsupported unmarshal field type"))
                }
                // be compatible with empty value
                if len(bs) == 0 {
                        bs = []byte("null")
                }

                return tx.AddError(json.Unmarshal(bs, &obj))
        }
}

func @137:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/candy.go:

137	`func() { opt.log.Info(ctx, "scan end [count[%v]]", count) }`

func JsonMarshalFn

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/model.go:

func JsonMarshalFn(tx *gorm.DB, obj, field any) func() error {
        return func() (err error) {
                if tx.Error != nil {
                        return
                }

                switch v := field.(type) {
                case **string, **[]byte, *string, *[]byte:
                        if v == nil {
                                return
                        }
                        bs, err := json.Marshal(obj)
                        if err != nil {
                                return tx.AddError(errors.Wrap(err, "gorm json marshal error"))
                        }
                        switch f := field.(type) {
                        case *string:
                                *f = string(bs)
                        case **string:
                                *f = utils.AnyPtr(string(bs))
                        case *[]byte:
                                *f = bs
                        case **[]byte:
                                *f = utils.AnyPtr(bs)
                        }
                default:
                        return tx.AddError(errors.New("unsupported marshal field type"))
                }
                return
        }

}

func ScanLog

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/candy.go:

func ScanLog(log log.Loggable) utils.OptionFunc[scanOption] {
        return func(o *scanOption) {
                o.log = log
        }
}

func @80:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/candy.go:

80	`func(o *scanOption) {`
81	`o.limit = limit`
82	`}`

func ScanLimit

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/candy.go:

func ScanLimit(limit int) utils.OptionFunc[scanOption] {
        return func(o *scanOption) {
                o.limit = limit
        }
}

func ScanWhere

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/candy.go:

func ScanWhere(where any, sqlAndArguments ...any) utils.OptionFunc[scanOption] {
        return func(o *scanOption) {
                o.where = where
                o.sqlAndArguments = sqlAndArguments
        }
}

func @47:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/candy.go:

47	`func(o *scanOption) {`
48	`o.dbName = dbName`
49	`}`

func ScanUse

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/candy.go:

func ScanUse(dbName string) utils.OptionFunc[scanOption] {
        return func(o *scanOption) {
                o.dbName = dbName
        }
}

func BusinessSoftDeleted.BizCreateTime

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/model.go:

174	`func (b *BusinessSoftDeleted) BizCreateTime() time.Time {`
175	`return utils.GetTime(b.BizCreateTimeMs)`
176	`}`

Package Overview: github.com/wfusion/gofusion/db/callbacks 44.0%

Please select a function to see what's left for testing.

`SoftDelete(...)`	`github.com/wfusion/gofusion/db/callbacks/soft_delete.go`	`100.0%`	`3/3`
`BuildQuerySQL(...)`	`github.com/wfusion/gofusion/db/callbacks/build_sql.go`	`100.0%`	`1/1`
`BuildUpdateSQL(...)`	`github.com/wfusion/gofusion/db/callbacks/build_sql.go`	`90.9%`	`10/11`
`checkMissingWhereConditions(...)`	`github.com/wfusion/gofusion/db/callbacks/soft_delete.go`	`88.9%`	`8/9`
`BuildDeleteSQL(...)`	`github.com/wfusion/gofusion/db/callbacks/build_sql.go`	`85.3%`	`29/34`
`@43:67(...)`	`github.com/wfusion/gofusion/db/callbacks/soft_delete.go`	`78.6%`	`11/14`
`@15:67(...)`	`github.com/wfusion/gofusion/db/callbacks/soft_delete.go`	`53.3%`	`8/15`
`@29:49(...)`	`github.com/wfusion/gofusion/db/callbacks/auto_incr.go`	`0.0%`	`0/47`
`BuildCreateSQL(...)`	`github.com/wfusion/gofusion/db/callbacks/build_sql.go`	`0.0%`	`0/16`
`CreateAutoIncr(...)`	`github.com/wfusion/gofusion/db/callbacks/auto_incr.go`	`0.0%`	`0/8`
`@53:12(...)`	`github.com/wfusion/gofusion/db/callbacks/auto_incr.go`	`0.0%`	`0/1`

func SoftDelete

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/callbacks/soft_delete.go:

func SoftDelete(db *gorm.DB) {
        // update callback
        comUtl.MustSuccess(db.Callback().Update().Replace("gorm:update", func(db *gorm.DB) {
                if db.Error != nil {
                        return
                }

                BuildUpdateSQL(db)
                checkMissingWhereConditions(db)

                if !db.DryRun && db.Error == nil {
                        if ok, mode := hasReturning(db, utils.Contains(db.Callback().Update().Clauses, "RETURNING")); ok {
                                if rows, err := db.Statement.ConnPool.QueryContext(db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...); db.AddError(err) == nil {
                                        dest := db.Statement.Dest
                                        db.Statement.Dest = db.Statement.ReflectValue.Addr().Interface()
                                        gorm.Scan(rows, db, mode)
                                        db.Statement.Dest = dest
                                        _ = db.AddError(rows.Close())
                                }
                        } else {
                                result, err := db.Statement.ConnPool.ExecContext(db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...)

                                if db.AddError(err) == nil {
                                        db.RowsAffected, _ = result.RowsAffected()
                                }
                        }
                }
        }))

        // delete callback
        comUtl.MustSuccess(db.Callback().Delete().Replace("gorm:delete", func(db *gorm.DB) {
                if db.Error != nil {
                        return
                }

                BuildDeleteSQL(db)
                checkMissingWhereConditions(db)

                if !db.DryRun && db.Error == nil {
                        ok, mode := hasReturning(db, utils.Contains(db.Callback().Delete().Clauses, "RETURNING"))
                        if !ok {
                                result, err := db.Statement.ConnPool.ExecContext(db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...)
                                if db.AddError(err) == nil {
                                        db.RowsAffected, _ = result.RowsAffected()
                                }

                                return
                        }

                        if rows, err := db.Statement.ConnPool.QueryContext(db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...); db.AddError(err) == nil {
                                gorm.Scan(rows, db, mode)
                                _ = db.AddError(rows.Close())
                        }
                }
        }))

        return
}

func BuildQuerySQL

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/callbacks/build_sql.go:

15	`func BuildQuerySQL(db *gorm.DB) {`
16	`callbacks.BuildQuerySQL(db)`
17	`}`

func BuildUpdateSQL

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/callbacks/build_sql.go:

func BuildUpdateSQL(db *gorm.DB) {
        if db.Statement.Schema != nil {
                for _, c := range db.Statement.Schema.UpdateClauses {
                        db.Statement.AddClause(c)
                }
        }

        if db.Statement.SQL.Len() == 0 {
                db.Statement.SQL.Grow(180)
                db.Statement.AddClauseIfNotExists(clause.Update{})
                if _, ok := db.Statement.Clauses["SET"]; !ok {
                        if set := callbacks.ConvertToAssignments(db.Statement); len(set) != 0 {
                                db.Statement.AddClause(set)
                        } else {
                                return
                        }
                }

                db.Statement.Build(db.Statement.BuildClauses...)
        }
}

func checkMissingWhereConditions

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/callbacks/soft_delete.go:

func checkMissingWhereConditions(db *gorm.DB) {
        if !db.AllowGlobalUpdate && db.Error == nil {
                where, withCondition := db.Statement.Clauses["WHERE"]
                if withCondition {
                        if softdelete.IsClausesWithSoftDelete(db.Statement.Clauses) {
                                whereClause, _ := where.Expression.(clause.Where)
                                withCondition = len(whereClause.Exprs) > 1
                        }
                }
                if !withCondition {
                        _ = db.AddError(gorm.ErrMissingWhereClause)
                }
                return
        }
}

func BuildDeleteSQL

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/callbacks/build_sql.go:

func BuildDeleteSQL(db *gorm.DB) {
        if db.Statement.Schema != nil {
                for _, c := range db.Statement.Schema.DeleteClauses {
                        db.Statement.AddClause(c)
                }
        }

        if db.Statement.SQL.Len() > 0 {
                return
        }

        stmt := db.Statement
        stmt.SQL.Grow(180)
        if softdelete.IsClausesWithSoftDelete(db.Statement.Clauses) {
                stmt.AddClauseIfNotExists(clause.Update{})

                if stmt.Schema != nil {
                        _, queryValues := schema.GetIdentityFieldValuesMap(stmt.Context, stmt.ReflectValue, stmt.Schema.PrimaryFields)
                        column, values := schema.ToQueryValues(stmt.Table, stmt.Schema.PrimaryFieldDBNames, queryValues)

                        if len(values) > 0 {
                                stmt.AddClause(clause.Where{Exprs: []clause.Expression{clause.IN{Column: column, Values: values}}})
                        }

                        if stmt.ReflectValue.CanAddr() && stmt.Dest != stmt.Model && stmt.Model != nil {
                                _, queryValues = schema.GetIdentityFieldValuesMap(stmt.Context, reflect.ValueOf(stmt.Model), stmt.Schema.PrimaryFields)
                                column, values = schema.ToQueryValues(stmt.Table, stmt.Schema.PrimaryFieldDBNames, queryValues)

                                if len(values) > 0 {
                                        stmt.AddClause(clause.Where{Exprs: []clause.Expression{clause.IN{Column: column, Values: values}}})
                                }
                        }
                }

                stmt.AddClauseIfNotExists(clause.From{})
                stmt.Build(stmt.DB.Callback().Update().Clauses...)
        } else {
                stmt.AddClauseIfNotExists(clause.Delete{})

                if stmt.Schema != nil {
                        _, queryValues := schema.GetIdentityFieldValuesMap(stmt.Context, stmt.ReflectValue, stmt.Schema.PrimaryFields)
                        column, values := schema.ToQueryValues(stmt.Table, stmt.Schema.PrimaryFieldDBNames, queryValues)

                        if len(values) > 0 {
                                stmt.AddClause(clause.Where{Exprs: []clause.Expression{clause.IN{Column: column, Values: values}}})
                        }

                        if stmt.ReflectValue.CanAddr() && stmt.Dest != stmt.Model && stmt.Model != nil {
                                _, queryValues = schema.GetIdentityFieldValuesMap(stmt.Context, reflect.ValueOf(stmt.Model), stmt.Schema.PrimaryFields)
                                column, values = schema.ToQueryValues(stmt.Table, stmt.Schema.PrimaryFieldDBNames, queryValues)

                                if len(values) > 0 {
                                        stmt.AddClause(clause.Where{Exprs: []clause.Expression{clause.IN{Column: column, Values: values}}})
                                }
                        }
                }

                stmt.AddClauseIfNotExists(clause.From{})
                stmt.Build(stmt.BuildClauses...)
        }
}

func @43:67

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/callbacks/soft_delete.go:

func(db *gorm.DB) {
                if db.Error != nil {
                        return
                }

                BuildDeleteSQL(db)
                checkMissingWhereConditions(db)

                if !db.DryRun && db.Error == nil {
                        ok, mode := hasReturning(db, utils.Contains(db.Callback().Delete().Clauses, "RETURNING"))
                        if !ok {
                                result, err := db.Statement.ConnPool.ExecContext(db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...)
                                if db.AddError(err) == nil {
                                        db.RowsAffected, _ = result.RowsAffected()
                                }

                                return
                        }

                        if rows, err := db.Statement.ConnPool.QueryContext(db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...); db.AddError(err) == nil {
                                gorm.Scan(rows, db, mode)
                                _ = db.AddError(rows.Close())
                        }
                }
        }

func @15:67

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/callbacks/soft_delete.go:

func(db *gorm.DB) {
                if db.Error != nil {
                        return
                }

                BuildUpdateSQL(db)
                checkMissingWhereConditions(db)

                if !db.DryRun && db.Error == nil {
                        if ok, mode := hasReturning(db, utils.Contains(db.Callback().Update().Clauses, "RETURNING")); ok {
                                if rows, err := db.Statement.ConnPool.QueryContext(db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...); db.AddError(err) == nil {
                                        dest := db.Statement.Dest
                                        db.Statement.Dest = db.Statement.ReflectValue.Addr().Interface()
                                        gorm.Scan(rows, db, mode)
                                        db.Statement.Dest = dest
                                        _ = db.AddError(rows.Close())
                                }
                        } else {
                                result, err := db.Statement.ConnPool.ExecContext(db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...)

                                if db.AddError(err) == nil {
                                        db.RowsAffected, _ = result.RowsAffected()
                                }
                        }
                }
        }

func @29:49

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/callbacks/auto_incr.go:

func(db *gorm.DB) {
                        if db.Error != nil {
                                return
                        }

                        BuildCreateSQL(db)

                        isDryRun := !db.DryRun && db.Error == nil
                        if !isDryRun {
                                return
                        }

                        ok, mode := hasReturning(db, utils.Contains(db.Callback().Create().Clauses, "RETURNING"))
                        if ok {
                                if c, ok := db.Statement.Clauses["ON CONFLICT"]; ok {
                                        if onConflict, _ := c.Expression.(clause.OnConflict); onConflict.DoNothing {
                                                mode |= gorm.ScanOnConflictDoNothing
                                        }
                                }

                                rows, err := db.Statement.ConnPool.QueryContext(
                                        db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...,
                                )
                                if db.AddError(err) == nil {
                                        defer func() { _ = db.AddError(rows.Close()) }()
                                        gorm.Scan(rows, db, mode)
                                }

                                return
                        }

                        result, err := db.Statement.ConnPool.ExecContext(
                                db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...,
                        )
                        if err != nil {
                                _ = db.AddError(err)
                                return
                        }

                        db.RowsAffected, _ = result.RowsAffected()
                        if db.RowsAffected != 0 && db.Statement.Schema != nil &&
                                db.Statement.Schema.PrioritizedPrimaryField != nil &&
                                db.Statement.Schema.PrioritizedPrimaryField.HasDefaultValue {
                                insertID, err := result.LastInsertId()
                                insertOk := err == nil && insertID > 0
                                if !insertOk {
                                        _ = db.AddError(err)
                                        return
                                }

                                switch db.Statement.ReflectValue.Kind() {
                                case reflect.Slice, reflect.Array:
                                        if lastInsertIDReversed {
                                                for i := db.Statement.ReflectValue.Len() - 1; i >= 0; i-- {
                                                        rv := db.Statement.ReflectValue.Index(i)
                                                        if reflect.Indirect(rv).Kind() != reflect.Struct {
                                                                break
                                                        }

                                                        _, isZero := db.Statement.Schema.PrioritizedPrimaryField.ValueOf(db.Statement.Context, rv)
                                                        if isZero {
                                                                _ = db.AddError(db.Statement.Schema.PrioritizedPrimaryField.Set(db.Statement.Context, rv, insertID))
                                                                //insertID -= db.Statement.Schema.PrioritizedPrimaryField.AutoIncrementIncrement
                                                                insertID -= autoIncrIncr
                                                        }
                                                }
                                        } else {
                                                for i := 0; i < db.Statement.ReflectValue.Len(); i++ {
                                                        rv := db.Statement.ReflectValue.Index(i)
                                                        if reflect.Indirect(rv).Kind() != reflect.Struct {
                                                                break
                                                        }

                                                        if _, isZero := db.Statement.Schema.PrioritizedPrimaryField.ValueOf(db.Statement.Context, rv); isZero {
                                                                _ = db.AddError(db.Statement.Schema.PrioritizedPrimaryField.Set(db.Statement.Context, rv, insertID))
                                                                //insertID += db.Statement.Schema.PrioritizedPrimaryField.AutoIncrementIncrement
                                                                insertID += autoIncrIncr
                                                        }
                                                }
                                        }
                                case reflect.Struct:
                                        _, isZero := db.Statement.Schema.PrioritizedPrimaryField.ValueOf(db.Statement.Context, db.Statement.ReflectValue)
                                        if isZero {
                                                _ = db.AddError(db.Statement.Schema.PrioritizedPrimaryField.Set(db.Statement.Context, db.Statement.ReflectValue, insertID))
                                        }
                                }
                        }
                }

func BuildCreateSQL

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/callbacks/build_sql.go:

func BuildCreateSQL(db *gorm.DB) {
        supportReturning := utils.Contains(db.Callback().Create().Clauses, "RETURNING")
        if db.Statement.Schema != nil {
                if !db.Statement.Unscoped {
                        for _, c := range db.Statement.Schema.CreateClauses {
                                db.Statement.AddClause(c)
                        }
                }

                if supportReturning && len(db.Statement.Schema.FieldsWithDefaultDBValue) > 0 {
                        if _, ok := db.Statement.Clauses["RETURNING"]; !ok {
                                fromColumns := make([]clause.Column, 0, len(db.Statement.Schema.FieldsWithDefaultDBValue))
                                for _, field := range db.Statement.Schema.FieldsWithDefaultDBValue {
                                        fromColumns = append(fromColumns, clause.Column{Name: field.DBName})
                                }
                                db.Statement.AddClause(clause.Returning{Columns: fromColumns})
                        }
                }
        }

        if db.Statement.SQL.Len() == 0 {
                db.Statement.SQL.Grow(180)
                db.Statement.AddClauseIfNotExists(clause.Insert{})
                db.Statement.AddClause(callbacks.ConvertToCreateValues(db.Statement))

                db.Statement.Build(db.Statement.BuildClauses...)
        }
}

func CreateAutoIncr

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/callbacks/auto_incr.go:

func CreateAutoIncr(db *gorm.DB, gormDialector gorm.Dialector, autoIncrIncr int64) {
        withReturning := false
        dialector := gormDialector.(*Dialector)
        if !dialector.Config.SkipInitializeWithVersion && strings.Contains(dialector.ServerVersion, "MariaDB") {
                withReturning = checkVersion(dialector.ServerVersion, "10.5")
        }

        lastInsertIDReversed := false
        if !dialector.Config.DisableWithReturning && withReturning {
                lastInsertIDReversed = true
        }

        comUtl.MustSuccess(
                db.Callback().Create().Replace("gorm:create", func(db *gorm.DB) {
                        if db.Error != nil {
                                return
                        }

                        BuildCreateSQL(db)

                        isDryRun := !db.DryRun && db.Error == nil
                        if !isDryRun {
                                return
                        }

                        ok, mode := hasReturning(db, utils.Contains(db.Callback().Create().Clauses, "RETURNING"))
                        if ok {
                                if c, ok := db.Statement.Clauses["ON CONFLICT"]; ok {
                                        if onConflict, _ := c.Expression.(clause.OnConflict); onConflict.DoNothing {
                                                mode |= gorm.ScanOnConflictDoNothing
                                        }
                                }

                                rows, err := db.Statement.ConnPool.QueryContext(
                                        db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...,
                                )
                                if db.AddError(err) == nil {
                                        defer func() { _ = db.AddError(rows.Close()) }()
                                        gorm.Scan(rows, db, mode)
                                }

                                return
                        }

                        result, err := db.Statement.ConnPool.ExecContext(
                                db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...,
                        )
                        if err != nil {
                                _ = db.AddError(err)
                                return
                        }

                        db.RowsAffected, _ = result.RowsAffected()
                        if db.RowsAffected != 0 && db.Statement.Schema != nil &&
                                db.Statement.Schema.PrioritizedPrimaryField != nil &&
                                db.Statement.Schema.PrioritizedPrimaryField.HasDefaultValue {
                                insertID, err := result.LastInsertId()
                                insertOk := err == nil && insertID > 0
                                if !insertOk {
                                        _ = db.AddError(err)
                                        return
                                }

                                switch db.Statement.ReflectValue.Kind() {
                                case reflect.Slice, reflect.Array:
                                        if lastInsertIDReversed {
                                                for i := db.Statement.ReflectValue.Len() - 1; i >= 0; i-- {
                                                        rv := db.Statement.ReflectValue.Index(i)
                                                        if reflect.Indirect(rv).Kind() != reflect.Struct {
                                                                break
                                                        }

                                                        _, isZero := db.Statement.Schema.PrioritizedPrimaryField.ValueOf(db.Statement.Context, rv)
                                                        if isZero {
                                                                _ = db.AddError(db.Statement.Schema.PrioritizedPrimaryField.Set(db.Statement.Context, rv, insertID))
                                                                //insertID -= db.Statement.Schema.PrioritizedPrimaryField.AutoIncrementIncrement
                                                                insertID -= autoIncrIncr
                                                        }
                                                }
                                        } else {
                                                for i := 0; i < db.Statement.ReflectValue.Len(); i++ {
                                                        rv := db.Statement.ReflectValue.Index(i)
                                                        if reflect.Indirect(rv).Kind() != reflect.Struct {
                                                                break
                                                        }

                                                        if _, isZero := db.Statement.Schema.PrioritizedPrimaryField.ValueOf(db.Statement.Context, rv); isZero {
                                                                _ = db.AddError(db.Statement.Schema.PrioritizedPrimaryField.Set(db.Statement.Context, rv, insertID))
                                                                //insertID += db.Statement.Schema.PrioritizedPrimaryField.AutoIncrementIncrement
                                                                insertID += autoIncrIncr
                                                        }
                                                }
                                        }
                                case reflect.Struct:
                                        _, isZero := db.Statement.Schema.PrioritizedPrimaryField.ValueOf(db.Statement.Context, db.Statement.ReflectValue)
                                        if isZero {
                                                _ = db.AddError(db.Statement.Schema.PrioritizedPrimaryField.Set(db.Statement.Context, db.Statement.ReflectValue, insertID))
                                        }
                                }
                        }
                }),
        )
}

func @53:12

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/callbacks/auto_incr.go:

53	`func() { _ = db.AddError(rows.Close()) }`

Package Overview: github.com/wfusion/gofusion/db/plugins 61.0%

Please select a function to see what's left for testing.

`tableSharding.replaceStatementClauseAndSchema(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`8/8`
`@697:23(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`8/8`
`tableSharding.registerCallbacks(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`6/6`
`tableSharding.replaceOrderByTableName(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`6/6`
`tableSharding.Initialize(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`5/5`
`@718:23(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`5/5`
`newShardingDialector(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`4/4`
`shardingDialector.Migrator(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`4/4`
`@252:3(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`3/3`
`@274:3(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`3/3`
`@1102:5(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`2/2`
`@240:3(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`2/2`
`@1077:28(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`2/2`
`tableSharding.replaceCondition(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`2/2`
`@251:3(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`2/2`
`@1011:9(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`2/2`
`@262:3(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`2/2`
`@273:3(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`2/2`
`@294:9(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`1/1`
`tableSharding.updateCallback(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`1/1`
`tableSharding.rawCallback(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`1/1`
`tableSharding.queryCallback(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`1/1`
`@917:42(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`1/1`
`tableShardingIsInsert(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`1/1`
`tableSharding.isIgnored(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`1/1`
`tableSharding.createCallback(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`1/1`
`@332:37(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`1/1`
`tableSharding.replaceConstraint(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`1/1`
`@151:33(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`1/1`
`tableSharding.Name(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`1/1`
`tableSharding.deleteCallback(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`1/1`
`@1006:9(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`1/1`
`tableSharding.checkDiffSuffixesByModel(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`90.5%`	`19/21`
`@804:23(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`88.2%`	`15/17`
`tableSharding.suffixes(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`87.5%`	`7/8`
`@1049:10(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`87.5%`	`7/8`
`@1063:10(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`87.5%`	`7/8`
`tableSharding.ShardingByModelList(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`83.3%`	`15/18`
`@646:12(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`83.3%`	`5/6`
`shardingMigrator.AutoMigrate(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`81.2%`	`13/16`
`shardingMigrator.DropTable(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`81.2%`	`13/16`
`@371:15(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`80.0%`	`8/10`
`DefaultTableSharding(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`77.8%`	`14/18`
`@854:23(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`77.8%`	`7/9`
`tableSharding.setPrimaryKeyByModel(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`76.9%`	`10/13`
`@438:31(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`76.6%`	`36/47`
`tableSharding.dispatchTableByModel(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`75.6%`	`31/41`
`shardingMigrator.getShardingDst(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`75.0%`	`9/12`
`tableSharding.getModelReflectValue(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`75.0%`	`6/8`
`shardingMigrator.tableName(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`75.0%`	`6/8`
`tableSharding.wrapDispatchTableBySQL(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`75.0%`	`3/4`
`tableSharding.ignore(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`75.0%`	`3/4`
`tableSharding.nonInsertValue(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`71.4%`	`5/7`
`tableSharding.defaultShardingFunc(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`68.0%`	`17/25`
`tableSharding.ShardingIDGen(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`66.7%`	`2/3`
`@1093:5(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`60.0%`	`3/5`
`@1106:10(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`58.6%`	`17/29`
`tableSharding.createTableIfNotExists(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`54.5%`	`12/22`
`@1080:5(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`37.5%`	`3/8`
`tableSharding.dispatchTableBySQL(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`34.7%`	`26/75`
`@580:20(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`20.0%`	`6/30`
`tableSharding.insertValue(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`0.0%`	`0/35`
`tableSharding.ShardingByValues(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`0.0%`	`0/15`
`@655:11(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`0.0%`	`0/12`
`@581:22(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`0.0%`	`0/8`
`@241:3(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`0.0%`	`0/3`
`@263:3(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`0.0%`	`0/3`
`shardingDialector.SavePoint(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`0.0%`	`0/3`
`shardingDialector.RollbackTo(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`0.0%`	`0/3`
`@674:15(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`0.0%`	`0/3`
`@284:3(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`0.0%`	`0/2`
`@285:3(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`0.0%`	`0/2`
`@1003:10(...)`	`github.com/wfusion/gofusion/db/plugins/table_sharding.go`	`100.0%`	`0/0`

func tableSharding.replaceStatementClauseAndSchema

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (t *tableSharding) replaceStatementClauseAndSchema(db *gorm.DB, opt *tableShardingDispatchOption) {
        changeExprFunc := func(src []clause.Expression) (dst []clause.Expression) {
                changeTableFunc := func(src any) (dst any, ok bool) {
                        switch col := src.(type) {
                        case clause.Column:
                                if col.Table == t.config.Table {
                                        col.Table = db.Statement.Table
                                        return col, true
                                }
                        case clause.Table:
                                if col.Name == t.config.Table {
                                        col.Name = db.Statement.Table
                                        return col, true
                                }
                        }
                        return
                }
                dst = make([]clause.Expression, 0, len(src))
                for _, srcExpr := range src {
                        switch expr := srcExpr.(type) {
                        case clause.IN:
                                if col, ok := changeTableFunc(expr.Column); ok {
                                        expr.Column = col
                                }
                                dst = append(dst, expr)
                        case clause.Eq:
                                if col, ok := changeTableFunc(expr.Column); ok {
                                        expr.Column = col
                                }
                                dst = append(dst, expr)
                        case clause.Neq:
                                if col, ok := changeTableFunc(expr.Column); ok {
                                        expr.Column = col
                                }
                                dst = append(dst, expr)
                        case clause.Gt:
                                if col, ok := changeTableFunc(expr.Column); ok {
                                        expr.Column = col
                                }
                                dst = append(dst, expr)
                        case clause.Gte:
                                if col, ok := changeTableFunc(expr.Column); ok {
                                        expr.Column = col
                                }
                                dst = append(dst, expr)
                        case clause.Lt:
                                if col, ok := changeTableFunc(expr.Column); ok {
                                        expr.Column = col
                                }
                                dst = append(dst, expr)
                        case clause.Lte:
                                if col, ok := changeTableFunc(expr.Column); ok {
                                        expr.Column = col
                                }
                                dst = append(dst, expr)
                        case clause.Like:
                                if col, ok := changeTableFunc(expr.Column); ok {
                                        expr.Column = col
                                }
                                dst = append(dst, expr)
                        default:
                                dst = append(dst, expr)
                        }
                }
                return
        }
        changeClausesMapping := map[string]func(cls clause.Clause){
                "WHERE": func(cls clause.Clause) {
                        whereClause, ok := cls.Expression.(clause.Where)
                        if !ok {
                                return
                        }
                        whereClause.Exprs = changeExprFunc(whereClause.Exprs)
                        cls.Expression = whereClause
                        db.Statement.Clauses["WHERE"] = cls
                },
                "FROM": func(cls clause.Clause) {
                        fromClause, ok := cls.Expression.(clause.From)
                        if !ok {
                                return
                        }
                        tables := make([]clause.Table, 0, len(fromClause.Tables))
                        for _, table := range fromClause.Tables {
                                if table.Name == t.config.Table {
                                        table.Name = db.Statement.Table
                                        tables = append(tables, table)
                                } else {
                                        tables = append(tables, table)
                                }
                        }
                        fromClause.Tables = tables
                        cls.Expression = fromClause
                        db.Statement.Clauses["FROM"] = cls
                },
                // TODO: check if order by contains table name
                "ORDER BY": func(cls clause.Clause) {
                        _, ok := cls.Expression.(clause.OrderBy)
                        if !ok {
                                return
                        }
                },
        }

        for name, cls := range db.Statement.Clauses {
                if mappingFunc, ok := changeClausesMapping[name]; ok {
                        mappingFunc(cls)
                }
        }

        if opt.isInsert {
                db.Clauses(clause.Insert{Table: clause.Table{Name: db.Statement.Table}})
        } else {
                db.Clauses(clause.From{Tables: []clause.Table{{Name: db.Statement.Table}}})
        }
}

func @697:23

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func(node sqlparser.Node) (err error) {
                        n, ok := node.(*sqlparser.BinaryExpr)
                        if !ok {
                                return
                        }

                        x, ok := n.X.(*sqlparser.QualifiedRef)
                        if !ok || x.Table == nil || x.Table.Name != oldTableName {
                                return
                        }

                        x.Table.Name = newTableName
                        return
                }

func tableSharding.registerCallbacks

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (t *tableSharding) registerCallbacks(db *gorm.DB) {
        utils.MustSuccess(db.Callback().
                Create().
                After("gorm:before_create").
                Before("gorm:save_before_associations").
                Register(t.Name(), t.createCallback))

        utils.MustSuccess(db.Callback().
                Query().
                Before("gorm:query").
                Register(t.Name(), t.queryCallback))

        utils.MustSuccess(db.Callback().
                Update().
                After("gorm:before_update").
                Before("gorm:save_before_associations").
                Register(t.Name(), t.updateCallback))

        utils.MustSuccess(db.Callback().
                Delete().
                After("gorm:before_delete").
                Before("gorm:delete_before_associations").
                Register(t.Name(), t.deleteCallback))

        utils.MustSuccess(db.Callback().
                Row().
                Before("gorm:row").
                Register(t.Name(), t.queryCallback))

        utils.MustSuccess(db.Callback().
                Raw().
                Before("gorm:raw").
                Register(t.Name(), t.rawCallback))
}

func tableSharding.replaceOrderByTableName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (t *tableSharding) replaceOrderByTableName(
        orderBy []*sqlparser.OrderingTerm, oldName, newName string) []*sqlparser.OrderingTerm {
        for i, term := range orderBy {
                if x, ok := term.X.(*sqlparser.QualifiedRef); ok {
                        if x.Table.Name == oldName {
                                x.Table.Name = newName
                                orderBy[i].X = x
                        }
                }
        }
        return orderBy
}

func tableSharding.Initialize

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (t *tableSharding) Initialize(db *gorm.DB) (err error) {
        db.Dialector = newShardingDialector(db.Dialector, t)

        t.DB = db
        t.shardingFunc = t.defaultShardingFunc()
        t.registerCallbacks(db)
        return
}

func @718:23

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func(node sqlparser.Node) (err error) {
                        n, ok := node.(*sqlparser.QualifiedRef)
                        if !ok || n.Table == nil || n.Table.Name != oldTableName {
                                return
                        }

                        n.Table.Name = newTableName
                        return
                }

func newShardingDialector

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func newShardingDialector(d gorm.Dialector, s *tableSharding) shardingDialector {
        if sd, ok := d.(shardingDialector); ok {
                sd.shardingMap[s.config.Table] = s
                return sd
        }

        return shardingDialector{
                Dialector:   d,
                shardingMap: map[string]*tableSharding{s.config.Table: s},
        }
}

func shardingDialector.Migrator

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (s shardingDialector) Migrator(db *gorm.DB) gorm.Migrator {
        m := s.Dialector.Migrator(db)
        if (*tableSharding)(nil).isIgnored(db)() {
                return m
        }
        return &shardingMigrator{
                Migrator:    m,
                db:          db,
                shardingMap: s.shardingMap,
                dialector:   s.Dialector,
        }
}

func @252:3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func() bool {
                        callbacks.BuildQuerySQL(db)
                        t.wrapDispatchTableBySQL(db)
                        return true
                }

func @274:3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func() bool {
                        callbacks.BuildDeleteSQL(db)
                        t.wrapDispatchTableBySQL(db)
                        return true
                }

func @1102:5

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

1102	`func() bool { data = []byte(v); return true }`

func @240:3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

240	`func() bool { ok1, ok2 := t.dispatchTableByModel(db, tableShardingIsInsert()); return ok1 \|\| ok2 }`

func @1077:28

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func(v string) (data []byte) {
                        utils.IfAny(
                                // number
                                func() (ok bool) {
                                        num := new(big.Float)
                                        if _, ok = num.SetString(v); !ok {
                                                return
                                        }
                                        gobEncoded, err := num.GobEncode()
                                        if err != nil {
                                                return false
                                        }
                                        data = gobEncoded
                                        return
                                },
                                // uuid
                                func() bool {
                                        uid, err := uuid.Parse(v)
                                        if err != nil {
                                                return false
                                        }
                                        data = uid[:]
                                        return true
                                },
                                // bytes
                                func() bool { data = []byte(v); return true },
                        )
                        return
                }

func tableSharding.replaceCondition

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (t *tableSharding) replaceCondition(conditions sqlparser.Expr, oldTableName, newTableName string) (err error) {
        err = sqlparser.Walk(
                sqlparser.VisitFunc(func(node sqlparser.Node) (err error) {
                        n, ok := node.(*sqlparser.BinaryExpr)
                        if !ok {
                                return
                        }

                        x, ok := n.X.(*sqlparser.QualifiedRef)
                        if !ok || x.Table == nil || x.Table.Name != oldTableName {
                                return
                        }

                        x.Table.Name = newTableName
                        return
                }),
                conditions,
        )
        return
}

func @251:3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

251	`func() bool { ok1, ok2 := t.dispatchTableByModel(db); return ok1 \|\| ok2 }`

func @1011:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

1011	`func() bool {`
1012	`_, ok := db.Statement.Settings.Load(shardingIgnoreStoreKey)`
1013	`return ok`
1014	`}`

func @262:3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

262	`func() bool { ok1, ok2 := t.dispatchTableByModel(db); return ok1 \|\| ok2 }`

func @273:3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

273	`func() bool { ok1, ok2 := t.dispatchTableByModel(db); return ok1 \|\| ok2 }`

func @294:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

294	`func(t *tableShardingDispatchOption) {`
295	`t.isInsert = true`
296	`}`

func tableSharding.updateCallback

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (t *tableSharding) updateCallback(db *gorm.DB) {
        utils.IfAny(
                t.isIgnored(db),
                func() bool { ok1, ok2 := t.dispatchTableByModel(db); return ok1 || ok2 },
                func() bool {
                        callbacks.BuildUpdateSQL(db)
                        t.wrapDispatchTableBySQL(db)
                        return true
                },
        )
}

func tableSharding.rawCallback

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (t *tableSharding) rawCallback(db *gorm.DB) {
        utils.IfAny(
                t.isIgnored(db),
                func() bool { ok1, ok2 := t.dispatchTableByModel(db); return ok1 || ok2 },
                func() bool { t.wrapDispatchTableBySQL(db); return true },
        )
}

func tableSharding.queryCallback

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (t *tableSharding) queryCallback(db *gorm.DB) {
        utils.IfAny(
                t.isIgnored(db),
                func() bool { ok1, ok2 := t.dispatchTableByModel(db); return ok1 || ok2 },
                func() bool {
                        callbacks.BuildQuerySQL(db)
                        t.wrapDispatchTableBySQL(db)
                        return true
                },
        )
}

func @917:42

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

917	`func(v string) bool { return strings.EqualFold(v, key) }`

func tableShardingIsInsert

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func tableShardingIsInsert() utils.OptionFunc[tableShardingDispatchOption] {
        return func(t *tableShardingDispatchOption) {
                t.isInsert = true
        }
}

func tableSharding.isIgnored

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (t *tableSharding) isIgnored(db *gorm.DB) func() bool {
        return func() bool {
                _, ok := db.Statement.Settings.Load(shardingIgnoreStoreKey)
                return ok
        }
}

func tableSharding.createCallback

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (t *tableSharding) createCallback(db *gorm.DB) {
        utils.IfAny(
                t.isIgnored(db),
                func() bool { ok1, ok2 := t.dispatchTableByModel(db, tableShardingIsInsert()); return ok1 || ok2 },
                func() bool {
                        callbacks.BuildCreateSQL(db)
                        t.wrapDispatchTableBySQL(db, tableShardingIsInsert())
                        return true
                },
        )
}

func @332:37

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

332	`func(v string) bool { return strings.EqualFold(v, key) }`

func tableSharding.replaceConstraint

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (t *tableSharding) replaceConstraint(constraints sqlparser.Node, oldTableName, newTableName string) (err error) {
        return sqlparser.Walk(
                sqlparser.VisitFunc(func(node sqlparser.Node) (err error) {
                        n, ok := node.(*sqlparser.QualifiedRef)
                        if !ok || n.Table == nil || n.Table.Name != oldTableName {
                                return
                        }

                        n.Table.Name = newTableName
                        return
                }),
                constraints,
        )
}

func @151:33

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

151	`func(v string) bool { return strings.EqualFold(v, key) }`

func tableSharding.Name

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

132	`func (t *tableSharding) Name() string {`
133	`return fmt.Sprintf("gorm:sharding:%s:%s", t.config.Database, t.config.Table)`
134	`}`

func tableSharding.deleteCallback

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (t *tableSharding) deleteCallback(db *gorm.DB) {
        utils.IfAny(
                t.isIgnored(db),
                func() bool { ok1, ok2 := t.dispatchTableByModel(db); return ok1 || ok2 },
                func() bool {
                        callbacks.BuildDeleteSQL(db)
                        t.wrapDispatchTableBySQL(db)
                        return true
                },
        )
}

func @1006:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

1006	`func() {`
1007	`db.Statement.Settings.Delete(shardingIgnoreStoreKey)`
1008	`}`

func tableSharding.checkDiffSuffixesByModel

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (t *tableSharding) checkDiffSuffixesByModel(db *gorm.DB) (err error) {
        reflectVal := utils.IndirectValue(db.Statement.ReflectValue)
        if reflectVal.Kind() != reflect.Array && reflectVal.Kind() != reflect.Slice {
                return
        }

        suffix := ""
        for i := 0; i < reflectVal.Len(); i++ {
                reflectItemVal := reflect.Indirect(reflectVal.Index(i))
                values := make([]any, 0, len(t.config.ShardingKeys))
                for _, key := range t.config.ShardingKeys {
                        val := reflectItemVal.FieldByNameFunc(func(v string) bool { return strings.EqualFold(v, key) })
                        if !val.IsValid() {
                                val, _ = utils.GetGormColumnValue(reflectItemVal, key)
                        }
                        if !val.IsValid() {
                                return db.AddError(ErrMissingShardingKey)
                        }
                        values = append(values, val.Interface())
                }
                subSuffix, err := t.shardingFunc(db.Statement.Context, values...)
                if err != nil {
                        return db.AddError(err)
                }
                if suffix != "" && suffix != subSuffix {
                        return db.AddError(ErrDiffSuffixDML)
                }
                suffix = subSuffix
        }
        return
}

func @804:23

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func(node sqlparser.Node) (err error) {
                        n, ok := node.(*sqlparser.BinaryExpr)
                        if !ok {
                                return
                        }
                        if n.Op != sqlparser.EQ {
                                return
                        }

                        switch x := n.X.(type) {
                        case *sqlparser.Ident:
                                if x.Name != key {
                                        return
                                }
                        case *sqlparser.QualifiedRef:
                                if !ok || x.Table.Name != tableName || x.Column.Name != key {
                                        return
                                }
                        }

                        found = true
                        switch expr := n.Y.(type) {
                        case *sqlparser.BindExpr:
                                value = args[expr.Pos]
                        case *sqlparser.StringLit:
                                value = expr.Value
                        case *sqlparser.NumberLit:
                                value = expr.Value
                        default:
                                return sqlparser.ErrNotImplemented
                        }

                        return
                }

func tableSharding.suffixes

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (t *tableSharding) suffixes() (suffixes []string, err error) {
        switch {
        case t.config.ShardingKeyByRawValue:
                if len(t.config.ShardingKeysForMigrating) == 0 {
                        return nil, errors.New("sharding key by raw value but do not configure keys for migrating")
                }

                for _, shardingKey := range t.config.ShardingKeysForMigrating {
                        suffixes = append(suffixes, fmt.Sprintf(t.suffixFormat, shardingKey))
                }
        default:
                for i := 0; i < int(t.config.NumberOfShards); i++ {
                        suffixes = append(suffixes, fmt.Sprintf(t.suffixFormat, i))
                }
        }
        return
}

func @1049:10

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func(ctx context.Context, values ...any) (suffix string, err error) {
                        data := make([]string, 0, len(values))
                        for _, value := range values {
                                v, err := cast.ToStringE(value)
                                if err != nil {
                                        return "", err
                                }
                                data = append(data, v)
                        }
                        shardingKey := strings.Join(data, constant.Underline)
                        return fmt.Sprintf("_%s", shardingKey), nil
                }

func @1063:10

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func(ctx context.Context, values ...any) (suffix string, err error) {
                        params := make(map[string]any, len(t.config.ShardingKeys))
                        for idx, column := range t.config.ShardingKeys {
                                params[column] = values[idx]
                        }

                        result, err := t.config.ShardingKeyExpr(ctx, params)
                        if err != nil {
                                return
                        }
                        shardingKey := int64(math.Mod(cast.ToFloat64(result), numberOfShardsFloat64))
                        return fmt.Sprintf(t.suffixFormat, shardingKey), nil
                }

func tableSharding.ShardingByModelList

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (t *tableSharding) ShardingByModelList(ctx context.Context, src ...any) (dst map[string][]any, err error) {
        dst = make(map[string][]any, len(t.config.ShardingKeys))
        for _, m := range src {
                val := reflect.Indirect(reflect.ValueOf(m))
                shardingValues := make([]any, 0, len(t.config.ShardingKeys))
                for _, key := range t.config.ShardingKeys {
                        field := val.FieldByNameFunc(func(v string) bool { return strings.EqualFold(v, key) })
                        if !field.IsValid() {
                                field, _ = utils.GetGormColumnValue(val, key)
                        }
                        if !field.IsValid() {
                                return dst, ErrMissingShardingKey
                        }
                        if key == t.shardingPrimaryKey && field.IsZero() {
                                return dst, ErrInvalidID
                        }
                        shardingValues = append(shardingValues, field.Interface())
                }
                suffix, err := t.shardingFunc(ctx, shardingValues...)
                if err != nil {
                        return dst, err
                }
                dst[suffix] = append(dst[suffix], m)
        }
        return
}

func @646:12

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func(cls clause.Clause) {
                        whereClause, ok := cls.Expression.(clause.Where)
                        if !ok {
                                return
                        }
                        whereClause.Exprs = changeExprFunc(whereClause.Exprs)
                        cls.Expression = whereClause
                        db.Statement.Clauses["WHERE"] = cls
                }

func shardingMigrator.AutoMigrate

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (s *shardingMigrator) AutoMigrate(dst ...any) (err error) {
        sharding, ok := s.shardingMap[s.tableName(s.db, dst[0])]
        if !ok {
                defer (*tableSharding)(nil).ignore(s.db)() //nolint: revive // partial calling issue
                return s.Migrator.AutoMigrate(dst...)
        }

        stmt := &gorm.Statement{DB: sharding.DB}
        if sharding.isIgnored(sharding.DB)() {
                return s.dialector.Migrator(stmt.DB.Session(&gorm.Session{})).AutoMigrate(dst...)
        }

        shardingDst, err := s.getShardingDst(sharding, dst...)
        if err != nil {
                return err
        }

        defer sharding.ignore(sharding.DB)() //nolint: revive // partial calling issue
        for _, sd := range shardingDst {
                tx := stmt.DB.Session(&gorm.Session{}).Table(sd.table)
                if err = s.dialector.Migrator(tx).AutoMigrate(sd.dst); err != nil {
                        return err
                }
        }

        return
}

func shardingMigrator.DropTable

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (s *shardingMigrator) DropTable(dst ...any) (err error) {
        sharding, ok := s.shardingMap[s.tableName(s.db, dst[0])]
        if !ok {
                defer (*tableSharding)(nil).ignore(s.db)() //nolint: revive // partial calling issue
                return s.Migrator.DropTable(dst...)
        }

        stmt := &gorm.Statement{DB: sharding.DB}
        if sharding.isIgnored(sharding.DB)() {
                return s.dialector.Migrator(stmt.DB.Session(&gorm.Session{})).DropTable(dst...)
        }
        shardingDst, err := s.getShardingDst(sharding, dst...)
        if err != nil {
                return err
        }

        defer sharding.ignore(sharding.DB)() //nolint: revive // partial calling issue
        for _, sd := range shardingDst {
                tx := stmt.DB.Session(&gorm.Session{}).Table(sd.table)
                if err = s.dialector.Migrator(tx).DropTable(sd.table); err != nil {
                        return err
                }
        }

        return
}

func @371:15

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func(condition sqlparser.Node, tableName string, vars ...any) (suffix string, err error) {
                values := make([]any, 0, len(t.config.ShardingKeys))
                for _, key := range t.config.ShardingKeys {
                        val, err := t.nonInsertValue(condition, key, tableName, vars...)
                        if err != nil {
                                return "", db.AddError(err)
                        }
                        values = append(values, val)
                }

                suffix, err = t.shardingFunc(db.Statement.Context, values...)
                if err != nil {
                        return "", db.AddError(err)
                }
                return
        }

func DefaultTableSharding

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func DefaultTableSharding(config TableShardingConfig) TableSharding {
        if utils.IsStrBlank(config.Table) {
                panic(errors.New("missing sharding table name"))
        }
        if len(config.ShardingKeys) == 0 {
                panic(errors.New("missing sharding keys"))
        }
        if !config.ShardingKeyByRawValue && (config.NumberOfShards <= 0 || config.NumberOfShards >= 100000) {
                panic(errors.New("invalid number of shards"))
        }

        shardingKeySet := utils.NewSet(config.ShardingKeys...)
        shardingPrimaryKey := ""
        isShardingPrimaryKey := false
        if shardingKeySet.Contains("id") || shardingKeySet.Contains("ID") ||
                shardingKeySet.Contains("iD") || shardingKeySet.Contains("Id") {
                if config.PrimaryKeyGenerator == nil {
                        panic(errors.New("sharding by primary key but primary key generator not found"))
                }

                isShardingPrimaryKey = true
                for _, key := range config.ShardingKeys {
                        if key == "id" || key == "ID" || key == "Id" || key == "iD" {
                                shardingPrimaryKey = key
                                break
                        }
                }
        }

        return &tableSharding{
                config:               config,
                isShardingPrimaryKey: isShardingPrimaryKey,
                shardingPrimaryKey:   shardingPrimaryKey,
                shardingTableCreated: make(map[string]struct{}, config.NumberOfShards),
        }
}

func @854:23

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func(rv reflect.Value) (err error) {
                _, isZero := db.Statement.Schema.PrioritizedPrimaryField.ValueOf(db.Statement.Context, rv)
                if !isZero {
                        return
                }
                if t.config.PrimaryKeyGenerator == nil {
                        return ErrIDGeneratorNotFound
                }
                id, err := t.config.PrimaryKeyGenerator.Next(idgen.GormTx(db))
                if err != nil {
                        return
                }
                return db.Statement.Schema.PrioritizedPrimaryField.Set(db.Statement.Context, rv, id)
        }

func tableSharding.setPrimaryKeyByModel

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (t *tableSharding) setPrimaryKeyByModel(db *gorm.DB, opt *tableShardingDispatchOption) (err error) {
        if !opt.isInsert || db.Statement.Model == nil ||
                db.Statement.Schema == nil || db.Statement.Schema.PrioritizedPrimaryField == nil {
                return
        }
        setPrimaryKeyFunc := func(rv reflect.Value) (err error) {
                _, isZero := db.Statement.Schema.PrioritizedPrimaryField.ValueOf(db.Statement.Context, rv)
                if !isZero {
                        return
                }
                if t.config.PrimaryKeyGenerator == nil {
                        return ErrIDGeneratorNotFound
                }
                id, err := t.config.PrimaryKeyGenerator.Next(idgen.GormTx(db))
                if err != nil {
                        return
                }
                return db.Statement.Schema.PrioritizedPrimaryField.Set(db.Statement.Context, rv, id)
        }

        switch db.Statement.ReflectValue.Kind() {
        case reflect.Slice, reflect.Array:
                for i := 0; i < db.Statement.ReflectValue.Len(); i++ {
                        rv := db.Statement.ReflectValue.Index(i)
                        if reflect.Indirect(rv).Kind() != reflect.Struct {
                                break
                        }

                        if err = setPrimaryKeyFunc(rv); err != nil {
                                return
                        }
                }
        case reflect.Struct:
                if err = setPrimaryKeyFunc(db.Statement.ReflectValue); err != nil {
                        return
                }
        }

        return
}

func @438:31

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func(stmt *sqlparser.SelectStatement) (ok bool, err error) {
                        if stmt.Hint != nil && stmt.Hint.Value == "nosharding" {
                                return false, nil
                        }

                        switch tbl := stmt.FromItems.(type) {
                        case *sqlparser.TableName:
                                if tbl.TableName() != t.config.Table {
                                        return false, nil
                                }
                                suffix, e := getSuffix(stmt.Condition, t.config.Table, db.Statement.Vars...)
                                if e != nil {
                                        _ = db.AddError(e)
                                        return false, nil
                                }
                                oldTableName := tbl.TableName()
                                newTableName := oldTableName + suffix
                                stmt.FromItems = &sqlparser.TableName{Name: &sqlparser.Ident{Name: newTableName}}
                                stmt.OrderBy = t.replaceOrderByTableName(stmt.OrderBy, oldTableName, newTableName)
                                if e := t.replaceCondition(stmt.Condition, oldTableName, newTableName); err != nil {
                                        _ = db.AddError(e)
                                        return false, nil
                                }
                        case *sqlparser.JoinClause:
                                tblx, _ := tbl.X.(*sqlparser.TableName)
                                tbly, _ := tbl.Y.(*sqlparser.TableName)
                                isXSharding := tblx != nil && tblx.TableName() == t.config.Table
                                isYSharding := tbly != nil && tbly.TableName() == t.config.Table
                                oldTableName := ""
                                switch {
                                case isXSharding:
                                        oldTableName = tblx.TableName()
                                case isYSharding:
                                        oldTableName = tbly.TableName()
                                default:
                                        return false, nil
                                }
                                suffix, e := getSuffix(stmt.Condition, oldTableName, db.Statement.Vars...)
                                if e != nil {
                                        _ = db.AddError(e)
                                        return false, nil
                                }
                                newTableName := oldTableName + suffix
                                stmt.OrderBy = t.replaceOrderByTableName(stmt.OrderBy, oldTableName, newTableName)
                                if e := t.replaceCondition(stmt.Condition, oldTableName, newTableName); err != nil {
                                        _ = db.AddError(e)
                                        return false, nil
                                }
                                if e := t.replaceConstraint(tbl.Constraint, oldTableName, newTableName); err != nil {
                                        _ = db.AddError(e)
                                        return false, nil
                                }
                                if isXSharding {
                                        tblx.Name.Name = newTableName
                                } else {
                                        tbly.Name.Name = newTableName
                                }
                                if stmt.Columns != nil {
                                        for _, column := range *stmt.Columns {
                                                columnTbl, ok := column.Expr.(*sqlparser.QualifiedRef)
                                                if !ok || columnTbl.Table.Name != oldTableName {
                                                        continue
                                                }
                                                columnTbl.Table.Name = newTableName
                                        }
                                }
                        }
                        return true, nil
                }

func tableSharding.dispatchTableByModel

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (t *tableSharding) dispatchTableByModel(db *gorm.DB, opts ...utils.OptionExtender) (otherTable, ok bool) {
        if db.Statement.Model == nil || utils.IsBlank(db.Statement.ReflectValue.Interface()) {
                return
        }
        if db.Statement.Table != t.config.Table {
                otherTable = true
                return
        }
        if t.shardingTableModel == nil {
                if _, ok := db.Statement.Model.(schema.Tabler); ok {
                        cloneModel := clone.Clone(db.Statement.Model)
                        t.shardingTableModel = cloneModel
                }
        }

        opt := utils.ApplyOptions[tableShardingDispatchOption](opts...)
        if t.isShardingPrimaryKey {
                if err := t.setPrimaryKeyByModel(db, opt); err != nil {
                        _ = db.AddError(err)
                        return
                }
        }

        reflectVal, ok := t.getModelReflectValue(db)
        if !ok {
                return
        }
        if err := t.checkDiffSuffixesByModel(db); err != nil {
                return
        }

        values := make([]any, 0, len(t.config.ShardingKeys))
        for _, key := range t.config.ShardingKeys {
                val := reflectVal.FieldByNameFunc(func(v string) bool { return strings.EqualFold(v, key) })
                if !val.IsValid() {
                        val, _ = utils.GetGormColumnValue(reflectVal, key)
                }
                if !val.IsValid() {
                        _ = db.AddError(ErrMissingShardingKey)
                        return
                }
                values = append(values, val.Interface())
        }

        suffix, err := t.shardingFunc(db.Statement.Context, values...)
        if err != nil {
                _ = db.AddError(err)
                return
        }
        // cannot parse suffix from model
        if utils.IsStrBlank(suffix) || suffix == constant.Underline {
                return false, false
        }
        if err = t.createTableIfNotExists(db, db.Statement.Table, suffix); err != nil {
                _ = db.AddError(err)
                return
        }

        db.Statement.Table = db.Statement.Table + suffix
        t.replaceStatementClauseAndSchema(db, opt)
        ok = true
        return
}

func shardingMigrator.getShardingDst

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (s *shardingMigrator) getShardingDst(sharding *tableSharding, src ...any) (dst []shardingDst, err error) {
        for _, model := range src {
                stmt := &gorm.Statement{DB: sharding.DB}
                if err = stmt.Parse(model); err != nil {
                        return
                }

                // support sharding table
                suffixes, err := sharding.suffixes()
                if err != nil {
                        return nil, err
                }
                if len(suffixes) == 0 {
                        return nil, fmt.Errorf("sharding table:%s suffixes are empty", stmt.Table)
                }
                for _, suffix := range suffixes {
                        dst = append(dst, shardingDst{
                                table: stmt.Table + suffix,
                                dst:   model,
                        })
                }
        }
        return
}

func tableSharding.getModelReflectValue

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (t *tableSharding) getModelReflectValue(db *gorm.DB) (reflectVal reflect.Value, ok bool) {
        reflectVal = utils.IndirectValue(db.Statement.ReflectValue)
        if reflectVal.Kind() == reflect.Array || reflectVal.Kind() == reflect.Slice {
                if reflectVal.Len() == 0 {
                        return
                }
                reflectVal = utils.IndirectValue(reflectVal.Index(0))
        }

        if reflectVal.Kind() != reflect.Struct {
                return
        }

        return reflectVal, !utils.IsBlank(reflectVal.Interface())
}

func shardingMigrator.tableName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (s *shardingMigrator) tableName(db *gorm.DB, m any) (name string) {
        if tabler, ok := m.(schema.Tabler); ok {
                name = tabler.TableName()
        }
        if tabler, ok := m.(schema.TablerWithNamer); ok {
                name = tabler.TableName(db.NamingStrategy)
        }
        namingStrategy := reflect.ValueOf(db.NamingStrategy)
        if namingStrategy.CanConvert(gormSchemaEmbeddedNamer) {
                name = reflect.Indirect(namingStrategy.Convert(gormSchemaEmbeddedNamer)).FieldByName("Table").String()
        }
        return
}

func tableSharding.wrapDispatchTableBySQL

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (t *tableSharding) wrapDispatchTableBySQL(db *gorm.DB, opts ...utils.OptionExtender) {
        if ok, err := t.dispatchTableBySQL(db, opts...); err != nil || !ok {
                // not a dml
                if err != nil {
                        return
                }
                // not a sharding table
                if !ok {
                        // FIXME: reset sql parse result will get duplicated sql statement
                        // db.Statement.SQL = strings.Builder{}
                        // db.Statement.Vars = nil
                }
        }
}

func tableSharding.ignore

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (t *tableSharding) ignore(db *gorm.DB) func() {
        if _, ok := db.Statement.Settings.Load(shardingIgnoreStoreKey); ok {
                return func() {}
        }
        db.Statement.Settings.Store(shardingIgnoreStoreKey, nil)
        return func() {
                db.Statement.Settings.Delete(shardingIgnoreStoreKey)
        }
}

func tableSharding.nonInsertValue

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (t *tableSharding) nonInsertValue(condition sqlparser.Node, key, tableName string, args ...any) (
        value any, err error) {
        found := false
        err = sqlparser.Walk(
                sqlparser.VisitFunc(func(node sqlparser.Node) (err error) {
                        n, ok := node.(*sqlparser.BinaryExpr)
                        if !ok {
                                return
                        }
                        if n.Op != sqlparser.EQ {
                                return
                        }

                        switch x := n.X.(type) {
                        case *sqlparser.Ident:
                                if x.Name != key {
                                        return
                                }
                        case *sqlparser.QualifiedRef:
                                if !ok || x.Table.Name != tableName || x.Column.Name != key {
                                        return
                                }
                        }

                        found = true
                        switch expr := n.Y.(type) {
                        case *sqlparser.BindExpr:
                                value = args[expr.Pos]
                        case *sqlparser.StringLit:
                                value = expr.Value
                        case *sqlparser.NumberLit:
                                value = expr.Value
                        default:
                                return sqlparser.ErrNotImplemented
                        }

                        return
                }),
                condition,
        )
        if err != nil {
                return
        }
        if !found {
                return nil, ErrMissingShardingKey
        }
        return
}

func tableSharding.defaultShardingFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (t *tableSharding) defaultShardingFunc() func(ctx context.Context, values ...any) (suffix string, err error) {
        if !t.config.ShardingKeyByRawValue && t.config.NumberOfShards == 0 {
                panic(errors.New("missing number_of_shards config"))
        }
        t.suffixFormat = constant.Underline

        switch {
        case utils.IsStrNotBlank(t.config.CustomSuffix):
                t.suffixFormat += t.config.CustomSuffix
        case t.config.ShardingKeyByRawValue:
                t.suffixFormat += "%s"
        default:
                t.suffixFormat += strings.Join(t.config.ShardingKeys, constant.Underline)
        }

        numberOfShards := t.config.NumberOfShards
        if !strings.Contains(t.suffixFormat, "%") {
                if t.config.ShardingKeyByRawValue {
                        t.suffixFormat += "_%s"
                } else if numberOfShards < 10 {
                        t.suffixFormat += "_%01d"
                } else if numberOfShards < 100 {
                        t.suffixFormat += "_%02d"
                } else if numberOfShards < 1000 {
                        t.suffixFormat += "_%03d"
                } else if numberOfShards < 10000 {
                        t.suffixFormat += "_%04d"
                }
        }

        switch {
        case t.config.ShardingKeyByRawValue:
                return func(ctx context.Context, values ...any) (suffix string, err error) {
                        data := make([]string, 0, len(values))
                        for _, value := range values {
                                v, err := cast.ToStringE(value)
                                if err != nil {
                                        return "", err
                                }
                                data = append(data, v)
                        }
                        shardingKey := strings.Join(data, constant.Underline)
                        return fmt.Sprintf("_%s", shardingKey), nil
                }
        case t.config.ShardingKeyExpr != nil:
                numberOfShardsFloat64 := float64(numberOfShards)
                return func(ctx context.Context, values ...any) (suffix string, err error) {
                        params := make(map[string]any, len(t.config.ShardingKeys))
                        for idx, column := range t.config.ShardingKeys {
                                params[column] = values[idx]
                        }

                        result, err := t.config.ShardingKeyExpr(ctx, params)
                        if err != nil {
                                return
                        }
                        shardingKey := int64(math.Mod(cast.ToFloat64(result), numberOfShardsFloat64))
                        return fmt.Sprintf(t.suffixFormat, shardingKey), nil
                }
        default:
                stringToByteSliceFunc := func(v string) (data []byte) {
                        utils.IfAny(
                                // number
                                func() (ok bool) {
                                        num := new(big.Float)
                                        if _, ok = num.SetString(v); !ok {
                                                return
                                        }
                                        gobEncoded, err := num.GobEncode()
                                        if err != nil {
                                                return false
                                        }
                                        data = gobEncoded
                                        return
                                },
                                // uuid
                                func() bool {
                                        uid, err := uuid.Parse(v)
                                        if err != nil {
                                                return false
                                        }
                                        data = uid[:]
                                        return true
                                },
                                // bytes
                                func() bool { data = []byte(v); return true },
                        )
                        return
                }
                return func(ctx context.Context, values ...any) (suffix string, err error) {
                        size := 0
                        for _, value := range values {
                                s := binary.Size(value)
                                if s <= 0 {
                                        s = int(unsafe.Sizeof(value))
                                }
                                size += s
                        }
                        w := new(bytes.Buffer)
                        w.Grow(size)

                        for _, value := range values {
                                var data any
                                switch v := value.(type) {
                                case int, *int:
                                        data = utils.IntNarrow(cast.ToInt(v))
                                case uint, *uint:
                                        data = utils.UintNarrow(cast.ToUint(v))
                                case []int:
                                        data = make([]any, len(v))
                                        for i := 0; i < len(v); i++ {
                                                data.([]any)[i] = utils.IntNarrow(cast.ToInt(v))
                                        }
                                case []uint:
                                        data = make([]any, len(v))
                                        for i := 0; i < len(v); i++ {
                                                data.([]any)[i] = utils.UintNarrow(cast.ToUint(v))
                                        }
                                case string:
                                        data = stringToByteSliceFunc(v)
                                case []byte:
                                        data = stringToByteSliceFunc(utils.UnsafeBytesToString(v))
                                case uuid.UUID:
                                        data = v[:]
                                default:
                                        data = v
                                }
                                if err = binary.Write(w, binary.BigEndian, data); err != nil {
                                        return
                                }
                        }

                        // checksum mod shards
                        checksum := crc32.ChecksumIEEE(w.Bytes())
                        shardingKey := uint64(checksum) % uint64(numberOfShards)
                        suffix = fmt.Sprintf(t.suffixFormat, shardingKey)
                        return
                }
        }
}

func tableSharding.ShardingIDGen

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (t *tableSharding) ShardingIDGen(ctx context.Context) (id uint64, err error) {
        if t.config.PrimaryKeyGenerator == nil {
                return 0, ErrIDGeneratorNotFound
        }
        return t.config.PrimaryKeyGenerator.Next()
}

func @1093:5

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func() bool {
                                        uid, err := uuid.Parse(v)
                                        if err != nil {
                                                return false
                                        }
                                        data = uid[:]
                                        return true
                                }

func @1106:10

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func(ctx context.Context, values ...any) (suffix string, err error) {
                        size := 0
                        for _, value := range values {
                                s := binary.Size(value)
                                if s <= 0 {
                                        s = int(unsafe.Sizeof(value))
                                }
                                size += s
                        }
                        w := new(bytes.Buffer)
                        w.Grow(size)

                        for _, value := range values {
                                var data any
                                switch v := value.(type) {
                                case int, *int:
                                        data = utils.IntNarrow(cast.ToInt(v))
                                case uint, *uint:
                                        data = utils.UintNarrow(cast.ToUint(v))
                                case []int:
                                        data = make([]any, len(v))
                                        for i := 0; i < len(v); i++ {
                                                data.([]any)[i] = utils.IntNarrow(cast.ToInt(v))
                                        }
                                case []uint:
                                        data = make([]any, len(v))
                                        for i := 0; i < len(v); i++ {
                                                data.([]any)[i] = utils.UintNarrow(cast.ToUint(v))
                                        }
                                case string:
                                        data = stringToByteSliceFunc(v)
                                case []byte:
                                        data = stringToByteSliceFunc(utils.UnsafeBytesToString(v))
                                case uuid.UUID:
                                        data = v[:]
                                default:
                                        data = v
                                }
                                if err = binary.Write(w, binary.BigEndian, data); err != nil {
                                        return
                                }
                        }

                        // checksum mod shards
                        checksum := crc32.ChecksumIEEE(w.Bytes())
                        shardingKey := uint64(checksum) % uint64(numberOfShards)
                        suffix = fmt.Sprintf(t.suffixFormat, shardingKey)
                        return
                }

func tableSharding.createTableIfNotExists

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (t *tableSharding) createTableIfNotExists(db *gorm.DB, tableName, suffix string) (err error) {
        shardingTableName := tableName + suffix
        t.shardingTableCreatedMutex.RLock()
        if _, ok := t.shardingTableCreated[shardingTableName]; ok {
                t.shardingTableCreatedMutex.RUnlock()
                return
        }
        t.shardingTableCreatedMutex.RUnlock()
        t.shardingTableCreatedMutex.Lock()
        defer t.shardingTableCreatedMutex.Unlock()

        defer t.ignore(t.DB)() //nolint: revive // partial calling issue
        if t.DB.Migrator().HasTable(shardingTableName) {
                t.shardingTableCreated[shardingTableName] = struct{}{}
                return
        }

        model := db.Statement.Model
        if model == nil {
                model = t.shardingTableModel
        }
        if model == nil {
                return ErrShardingModelNotFound
        }
        tx := t.DB.Session(&gorm.Session{}).Table(shardingTableName)
        if err = db.Dialector.Migrator(tx).AutoMigrate(db.Statement.Model); err != nil {
                return err
        }
        t.shardingTableCreated[shardingTableName] = struct{}{}
        return
}

func @1080:5

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func() (ok bool) {
                                        num := new(big.Float)
                                        if _, ok = num.SetString(v); !ok {
                                                return
                                        }
                                        gobEncoded, err := num.GobEncode()
                                        if err != nil {
                                                return false
                                        }
                                        data = gobEncoded
                                        return
                                }

func tableSharding.dispatchTableBySQL

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (t *tableSharding) dispatchTableBySQL(db *gorm.DB, opts ...utils.OptionExtender) (ok bool, err error) {
        expr, err := sqlparser.NewParser(strings.NewReader(db.Statement.SQL.String())).ParseStatement()
        if err != nil {
                // maybe not a dml, so we ignore this error
                return
        }

        getSuffix := func(condition sqlparser.Node, tableName string, vars ...any) (suffix string, err error) {
                values := make([]any, 0, len(t.config.ShardingKeys))
                for _, key := range t.config.ShardingKeys {
                        val, err := t.nonInsertValue(condition, key, tableName, vars...)
                        if err != nil {
                                return "", db.AddError(err)
                        }
                        values = append(values, val)
                }

                suffix, err = t.shardingFunc(db.Statement.Context, values...)
                if err != nil {
                        return "", db.AddError(err)
                }
                return
        }

        newSQL := ""
        switch stmt := expr.(type) {
        case *sqlparser.InsertStatement:
                if stmt.TableName.TableName() != t.config.Table {
                        return
                }

                suffix := ""
                for _, insertExpression := range stmt.Expressions {
                        values, id, e := t.insertValue(t.config.ShardingKeys, stmt.ColumnNames,
                                insertExpression.Exprs, db.Statement.Vars...)
                        if e != nil {
                                _ = db.AddError(e)
                                return
                        }
                        if t.isShardingPrimaryKey && id == 0 {
                                if t.config.PrimaryKeyGenerator == nil {
                                        _ = db.AddError(ErrIDGeneratorNotFound)
                                        return
                                }
                                if id, e = t.config.PrimaryKeyGenerator.Next(idgen.GormTx(db)); e != nil {
                                        _ = db.AddError(e)
                                        return
                                }
                                stmt.ColumnNames = append(stmt.ColumnNames, &sqlparser.Ident{Name: "id"})
                                insertExpression.Exprs = append(insertExpression.Exprs, &sqlparser.NumberLit{Value: cast.ToString(id)})
                                values, _, _ = t.insertValue(t.config.ShardingKeys, stmt.ColumnNames,
                                        insertExpression.Exprs, db.Statement.Vars...)
                        }

                        subSuffix, e := t.shardingFunc(db.Statement.Context, values...)
                        if e != nil {
                                _ = db.AddError(e)
                                return
                        }

                        if suffix != "" && suffix != subSuffix {
                                _ = db.AddError(ErrDiffSuffixDML)
                                return
                        }
                        suffix = subSuffix
                }
                // FIXME: could not find the table schema to migrate
                if e := t.createTableIfNotExists(db, db.Statement.Table, suffix); e != nil {
                        _ = db.AddError(e)
                        return
                }
                stmt.TableName = &sqlparser.TableName{Name: &sqlparser.Ident{Name: stmt.TableName.TableName() + suffix}}
                newSQL = stmt.String()
        case *sqlparser.SelectStatement:
                parseSelectStatementFunc := func(stmt *sqlparser.SelectStatement) (ok bool, err error) {
                        if stmt.Hint != nil && stmt.Hint.Value == "nosharding" {
                                return false, nil
                        }

                        switch tbl := stmt.FromItems.(type) {
                        case *sqlparser.TableName:
                                if tbl.TableName() != t.config.Table {
                                        return false, nil
                                }
                                suffix, e := getSuffix(stmt.Condition, t.config.Table, db.Statement.Vars...)
                                if e != nil {
                                        _ = db.AddError(e)
                                        return false, nil
                                }
                                oldTableName := tbl.TableName()
                                newTableName := oldTableName + suffix
                                stmt.FromItems = &sqlparser.TableName{Name: &sqlparser.Ident{Name: newTableName}}
                                stmt.OrderBy = t.replaceOrderByTableName(stmt.OrderBy, oldTableName, newTableName)
                                if e := t.replaceCondition(stmt.Condition, oldTableName, newTableName); err != nil {
                                        _ = db.AddError(e)
                                        return false, nil
                                }
                        case *sqlparser.JoinClause:
                                tblx, _ := tbl.X.(*sqlparser.TableName)
                                tbly, _ := tbl.Y.(*sqlparser.TableName)
                                isXSharding := tblx != nil && tblx.TableName() == t.config.Table
                                isYSharding := tbly != nil && tbly.TableName() == t.config.Table
                                oldTableName := ""
                                switch {
                                case isXSharding:
                                        oldTableName = tblx.TableName()
                                case isYSharding:
                                        oldTableName = tbly.TableName()
                                default:
                                        return false, nil
                                }
                                suffix, e := getSuffix(stmt.Condition, oldTableName, db.Statement.Vars...)
                                if e != nil {
                                        _ = db.AddError(e)
                                        return false, nil
                                }
                                newTableName := oldTableName + suffix
                                stmt.OrderBy = t.replaceOrderByTableName(stmt.OrderBy, oldTableName, newTableName)
                                if e := t.replaceCondition(stmt.Condition, oldTableName, newTableName); err != nil {
                                        _ = db.AddError(e)
                                        return false, nil
                                }
                                if e := t.replaceConstraint(tbl.Constraint, oldTableName, newTableName); err != nil {
                                        _ = db.AddError(e)
                                        return false, nil
                                }
                                if isXSharding {
                                        tblx.Name.Name = newTableName
                                } else {
                                        tbly.Name.Name = newTableName
                                }
                                if stmt.Columns != nil {
                                        for _, column := range *stmt.Columns {
                                                columnTbl, ok := column.Expr.(*sqlparser.QualifiedRef)
                                                if !ok || columnTbl.Table.Name != oldTableName {
                                                        continue
                                                }
                                                columnTbl.Table.Name = newTableName
                                        }
                                }
                        }
                        return true, nil
                }
                for compound := stmt; compound != nil; compound = compound.Compound {
                        if ok, err = parseSelectStatementFunc(compound); !ok || err != nil {
                                return
                        }
                }

                newSQL = stmt.String()

        case *sqlparser.UpdateStatement:
                if stmt.TableName.TableName() != t.config.Table {
                        return
                }

                suffix, e := getSuffix(stmt.Condition, t.config.Table, db.Statement.Vars...)
                if e != nil {
                        _ = db.AddError(e)
                        return
                }

                oldTableName := stmt.TableName.TableName()
                newTableName := oldTableName + suffix
                stmt.TableName = &sqlparser.TableName{Name: &sqlparser.Ident{Name: newTableName}}
                if e := t.replaceCondition(stmt.Condition, oldTableName, newTableName); err != nil {
                        _ = db.AddError(e)
                        return false, nil
                }
                newSQL = stmt.String()
        case *sqlparser.DeleteStatement:
                if stmt.TableName.TableName() != t.config.Table {
                        return
                }

                suffix, e := getSuffix(stmt.Condition, t.config.Table, db.Statement.Vars...)
                if e != nil {
                        _ = db.AddError(e)
                        return
                }

                oldTableName := stmt.TableName.TableName()
                newTableName := oldTableName + suffix
                stmt.TableName = &sqlparser.TableName{Name: &sqlparser.Ident{Name: newTableName}}
                if e := t.replaceCondition(stmt.Condition, oldTableName, newTableName); err != nil {
                        _ = db.AddError(e)
                        return false, nil
                }
                newSQL = stmt.String()
        default:
                _ = db.AddError(sqlparser.ErrNotImplemented)
                return
        }

        sb := strings.Builder{}
        sb.Grow(len(newSQL))
        sb.WriteString(newSQL)
        db.Statement.SQL = sb

        return true, nil
}

func @580:20

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func(src []clause.Expression) (dst []clause.Expression) {
                changeTableFunc := func(src any) (dst any, ok bool) {
                        switch col := src.(type) {
                        case clause.Column:
                                if col.Table == t.config.Table {
                                        col.Table = db.Statement.Table
                                        return col, true
                                }
                        case clause.Table:
                                if col.Name == t.config.Table {
                                        col.Name = db.Statement.Table
                                        return col, true
                                }
                        }
                        return
                }
                dst = make([]clause.Expression, 0, len(src))
                for _, srcExpr := range src {
                        switch expr := srcExpr.(type) {
                        case clause.IN:
                                if col, ok := changeTableFunc(expr.Column); ok {
                                        expr.Column = col
                                }
                                dst = append(dst, expr)
                        case clause.Eq:
                                if col, ok := changeTableFunc(expr.Column); ok {
                                        expr.Column = col
                                }
                                dst = append(dst, expr)
                        case clause.Neq:
                                if col, ok := changeTableFunc(expr.Column); ok {
                                        expr.Column = col
                                }
                                dst = append(dst, expr)
                        case clause.Gt:
                                if col, ok := changeTableFunc(expr.Column); ok {
                                        expr.Column = col
                                }
                                dst = append(dst, expr)
                        case clause.Gte:
                                if col, ok := changeTableFunc(expr.Column); ok {
                                        expr.Column = col
                                }
                                dst = append(dst, expr)
                        case clause.Lt:
                                if col, ok := changeTableFunc(expr.Column); ok {
                                        expr.Column = col
                                }
                                dst = append(dst, expr)
                        case clause.Lte:
                                if col, ok := changeTableFunc(expr.Column); ok {
                                        expr.Column = col
                                }
                                dst = append(dst, expr)
                        case clause.Like:
                                if col, ok := changeTableFunc(expr.Column); ok {
                                        expr.Column = col
                                }
                                dst = append(dst, expr)
                        default:
                                dst = append(dst, expr)
                        }
                }
                return
        }

func tableSharding.insertValue

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (t *tableSharding) insertValue(keys []string, names []*sqlparser.Ident, exprs []sqlparser.Expr, args ...any) (
        values []any, id uint64, err error) {
        if len(names) != len(exprs) {
                return nil, 0, ErrColumnAndExprMisMatch
        }

        for _, key := range keys {
                found := false
                isPrimaryKey := key == t.shardingPrimaryKey
                for i, name := range names {
                        if name.Name != key {
                                continue
                        }

                        switch expr := exprs[i].(type) {
                        case *sqlparser.BindExpr:
                                if !isPrimaryKey {
                                        values = append(values, args[expr.Pos])
                                } else {
                                        switch v := args[expr.Pos].(type) {
                                        case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, float32, float64, string:
                                                if id, err = cast.ToUint64E(v); err != nil {
                                                        return nil, 0, errors.Wrapf(err, "parse id as uint64 failed [%v]", v)
                                                }
                                        default:
                                                return nil, 0, ErrInvalidID
                                        }
                                        if id != 0 {
                                                values = append(values, args[expr.Pos])
                                        }
                                }
                        case *sqlparser.StringLit:
                                if !isPrimaryKey {
                                        values = append(values, expr.Value)
                                } else {
                                        if id, err = cast.ToUint64E(expr.Value); err != nil {
                                                return nil, 0, errors.Wrapf(err, "parse id as uint64 failed [%s]", expr.Value)
                                        }
                                        if id != 0 {
                                                values = append(values, expr.Value)
                                        }
                                }
                        case *sqlparser.NumberLit:
                                if !isPrimaryKey {
                                        values = append(values, expr.Value)
                                } else {
                                        if id, err = strconv.ParseUint(expr.Value, 10, 64); err != nil {
                                                return nil, 0, errors.Wrapf(err,
                                                        "parse id as uint64 failed [%s]", expr.Value)
                                        }
                                        if id != 0 {
                                                values = append(values, expr.Value)
                                        }
                                }
                        default:
                                return nil, 0, sqlparser.ErrNotImplemented
                        }

                        found = true
                        break
                }
                if !found && !isPrimaryKey {
                        return nil, 0, ErrMissingShardingKey
                }
        }

        return
}

func tableSharding.ShardingByValues

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (t *tableSharding) ShardingByValues(ctx context.Context, src []map[string]any) (
        dst map[string][]map[string]any, err error) {
        dst = make(map[string][]map[string]any, len(t.config.ShardingKeys))
        for _, col := range src {
                values := make([]any, 0, len(col))
                for _, k := range t.config.ShardingKeys {
                        value, ok := col[k]
                        if !ok {
                                return dst, errors.Errorf("sharding key not found [column[%s]]", k)
                        }
                        if k == t.shardingPrimaryKey && utils.IsBlank(value) {
                                return dst, ErrInvalidID
                        }
                        values = append(values, value)
                }
                suffix, err := t.shardingFunc(ctx, values...)
                if err != nil {
                        return dst, err
                }
                dst[suffix] = append(dst[suffix], col)
        }
        return
}

func @655:11

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func(cls clause.Clause) {
                        fromClause, ok := cls.Expression.(clause.From)
                        if !ok {
                                return
                        }
                        tables := make([]clause.Table, 0, len(fromClause.Tables))
                        for _, table := range fromClause.Tables {
                                if table.Name == t.config.Table {
                                        table.Name = db.Statement.Table
                                        tables = append(tables, table)
                                } else {
                                        tables = append(tables, table)
                                }
                        }
                        fromClause.Tables = tables
                        cls.Expression = fromClause
                        db.Statement.Clauses["FROM"] = cls
                }

func @581:22

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func(src any) (dst any, ok bool) {
                        switch col := src.(type) {
                        case clause.Column:
                                if col.Table == t.config.Table {
                                        col.Table = db.Statement.Table
                                        return col, true
                                }
                        case clause.Table:
                                if col.Name == t.config.Table {
                                        col.Name = db.Statement.Table
                                        return col, true
                                }
                        }
                        return
                }

func @241:3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func() bool {
                        callbacks.BuildCreateSQL(db)
                        t.wrapDispatchTableBySQL(db, tableShardingIsInsert())
                        return true
                }

func @263:3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func() bool {
                        callbacks.BuildUpdateSQL(db)
                        t.wrapDispatchTableBySQL(db)
                        return true
                }

func shardingDialector.SavePoint

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (s shardingDialector) SavePoint(tx *gorm.DB, name string) error {
        if savePointer, ok := s.Dialector.(gorm.SavePointerDialectorInterface); ok {
                return savePointer.SavePoint(tx, name)
        } else {
                return gorm.ErrUnsupportedDriver
        }
}

func shardingDialector.RollbackTo

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func (s shardingDialector) RollbackTo(tx *gorm.DB, name string) error {
        if savePointer, ok := s.Dialector.(gorm.SavePointerDialectorInterface); ok {
                return savePointer.RollbackTo(tx, name)
        } else {
                return gorm.ErrUnsupportedDriver
        }
}

func @674:15

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

func(cls clause.Clause) {
                        _, ok := cls.Expression.(clause.OrderBy)
                        if !ok {
                                return
                        }
                }

func @284:3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

284	`func() bool { ok1, ok2 := t.dispatchTableByModel(db); return ok1 \|\| ok2 }`

func @285:3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

285	`func() bool { t.wrapDispatchTableBySQL(db); return true }`

func @1003:10

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/plugins/table_sharding.go:

1003	`func() {}`

Package Overview: github.com/wfusion/gofusion/db/softdelete 59.0%

Please select a function to see what's left for testing.

`deletedDeleteClause.ModifyStatement(...)`	`github.com/wfusion/gofusion/db/softdelete/deleted.go`	`100.0%`	`8/8`
`@22:27(...)`	`github.com/wfusion/gofusion/db/softdelete/deletedat.go`	`100.0%`	`4/4`
`TimestampUpdateClause.ModifyStatement(...)`	`github.com/wfusion/gofusion/db/softdelete/timestamp.go`	`100.0%`	`2/2`
`@20:3(...)`	`github.com/wfusion/gofusion/db/softdelete/types.go`	`100.0%`	`2/2`
`@24:25(...)`	`github.com/wfusion/gofusion/db/softdelete/deletedat.go`	`100.0%`	`2/2`
`@18:3(...)`	`github.com/wfusion/gofusion/db/softdelete/types.go`	`100.0%`	`2/2`
`IsClausesWithSoftDelete(...)`	`github.com/wfusion/gofusion/db/softdelete/types.go`	`100.0%`	`2/2`
`@21:3(...)`	`github.com/wfusion/gofusion/db/softdelete/types.go`	`100.0%`	`2/2`
`deletedUpdateClause.ModifyStatement(...)`	`github.com/wfusion/gofusion/db/softdelete/deleted.go`	`100.0%`	`2/2`
`@19:3(...)`	`github.com/wfusion/gofusion/db/softdelete/types.go`	`100.0%`	`2/2`
`PatchGormDeleteAt(...)`	`github.com/wfusion/gofusion/db/softdelete/deletedat.go`	`100.0%`	`2/2`
`Timestamp.UpdateClauses(...)`	`github.com/wfusion/gofusion/db/softdelete/timestamp.go`	`100.0%`	`1/1`
`Timestamp.QueryClauses(...)`	`github.com/wfusion/gofusion/db/softdelete/timestamp.go`	`100.0%`	`1/1`
`Timestamp.DeleteClauses(...)`	`github.com/wfusion/gofusion/db/softdelete/timestamp.go`	`100.0%`	`1/1`
`Deleted.DeleteClauses(...)`	`github.com/wfusion/gofusion/db/softdelete/deleted.go`	`100.0%`	`1/1`
`Timestamp.Scan(...)`	`github.com/wfusion/gofusion/db/softdelete/timestamp.go`	`100.0%`	`1/1`
`Deleted.QueryClauses(...)`	`github.com/wfusion/gofusion/db/softdelete/deleted.go`	`100.0%`	`1/1`
`Deleted.Value(...)`	`github.com/wfusion/gofusion/db/softdelete/deleted.go`	`100.0%`	`1/1`
`Deleted.UpdateClauses(...)`	`github.com/wfusion/gofusion/db/softdelete/deleted.go`	`100.0%`	`1/1`
`TimestampDeleteClause.ModifyStatement(...)`	`github.com/wfusion/gofusion/db/softdelete/timestamp.go`	`80.0%`	`8/10`
`Deleted.Scan(...)`	`github.com/wfusion/gofusion/db/softdelete/deleted.go`	`80.0%`	`4/5`
`deletedQueryClause.ModifyStatement(...)`	`github.com/wfusion/gofusion/db/softdelete/deleted.go`	`66.7%`	`8/12`
`TimestampQueryClause.ModifyStatement(...)`	`github.com/wfusion/gofusion/db/softdelete/timestamp.go`	`66.7%`	`8/12`
`Timestamp.Value(...)`	`github.com/wfusion/gofusion/db/softdelete/timestamp.go`	`66.7%`	`2/3`
`parseStatusZeroValueTag(...)`	`github.com/wfusion/gofusion/db/softdelete/deleted.go`	`50.0%`	`2/4`
`parseTimestampZeroValueTag(...)`	`github.com/wfusion/gofusion/db/softdelete/timestamp.go`	`50.0%`	`2/4`
`gormSoftDeleteDeleteClauseModifyStatement(...)`	`github.com/wfusion/gofusion/db/softdelete/deletedat.go`	`0.0%`	`0/10`
`Timestamp.UnmarshalJSON(...)`	`github.com/wfusion/gofusion/db/softdelete/timestamp.go`	`0.0%`	`0/7`
`Deleted.UnmarshalJSON(...)`	`github.com/wfusion/gofusion/db/softdelete/deleted.go`	`0.0%`	`0/7`
`Timestamp.MarshalJSON(...)`	`github.com/wfusion/gofusion/db/softdelete/timestamp.go`	`0.0%`	`0/3`
`deletedQueryClause.Name(...)`	`github.com/wfusion/gofusion/db/softdelete/deleted.go`	`0.0%`	`0/1`
`TimestampQueryClause.Name(...)`	`github.com/wfusion/gofusion/db/softdelete/timestamp.go`	`0.0%`	`0/1`
`deletedDeleteClause.Name(...)`	`github.com/wfusion/gofusion/db/softdelete/deleted.go`	`0.0%`	`0/1`
`TimestampDeleteClause.Name(...)`	`github.com/wfusion/gofusion/db/softdelete/timestamp.go`	`0.0%`	`0/1`
`Deleted.MarshalJSON(...)`	`github.com/wfusion/gofusion/db/softdelete/deleted.go`	`0.0%`	`0/1`
`deletedUpdateClause.Name(...)`	`github.com/wfusion/gofusion/db/softdelete/deleted.go`	`0.0%`	`0/1`
`TimestampUpdateClause.Name(...)`	`github.com/wfusion/gofusion/db/softdelete/timestamp.go`	`0.0%`	`0/1`
`TimestampUpdateClause.MergeClause(...)`	`github.com/wfusion/gofusion/db/softdelete/timestamp.go`	`100.0%`	`0/0`
`TimestampUpdateClause.Build(...)`	`github.com/wfusion/gofusion/db/softdelete/timestamp.go`	`100.0%`	`0/0`
`deletedUpdateClause.Build(...)`	`github.com/wfusion/gofusion/db/softdelete/deleted.go`	`100.0%`	`0/0`
`TimestampDeleteClause.Build(...)`	`github.com/wfusion/gofusion/db/softdelete/timestamp.go`	`100.0%`	`0/0`
`TimestampDeleteClause.MergeClause(...)`	`github.com/wfusion/gofusion/db/softdelete/timestamp.go`	`100.0%`	`0/0`
`deletedQueryClause.MergeClause(...)`	`github.com/wfusion/gofusion/db/softdelete/deleted.go`	`100.0%`	`0/0`
`TimestampQueryClause.MergeClause(...)`	`github.com/wfusion/gofusion/db/softdelete/timestamp.go`	`100.0%`	`0/0`
`TimestampQueryClause.Build(...)`	`github.com/wfusion/gofusion/db/softdelete/timestamp.go`	`100.0%`	`0/0`
`deletedUpdateClause.MergeClause(...)`	`github.com/wfusion/gofusion/db/softdelete/deleted.go`	`100.0%`	`0/0`
`deletedDeleteClause.Build(...)`	`github.com/wfusion/gofusion/db/softdelete/deleted.go`	`100.0%`	`0/0`
`deletedDeleteClause.MergeClause(...)`	`github.com/wfusion/gofusion/db/softdelete/deleted.go`	`100.0%`	`0/0`
`deletedQueryClause.Build(...)`	`github.com/wfusion/gofusion/db/softdelete/deleted.go`	`100.0%`	`0/0`

func deletedDeleteClause.ModifyStatement

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/deleted.go:

func (s deletedDeleteClause) ModifyStatement(stmt *gorm.Statement) {
        deleted := true
        setClauses := clause.Set{{Column: clause.Column{Name: s.Field.DBName}, Value: deleted}}
        if clauses, ok := stmt.Clauses[setClauses.Name()]; ok {
                if exprClauses, ok := clauses.Expression.(clause.Set); ok {
                        setClauses = append(setClauses, exprClauses...)
                }
        }
        stmt.AddClause(setClauses)
        stmt.SetColumn(s.Field.DBName, deleted, true)

        deletedQueryClause(s).ModifyStatement(stmt)
}

func @22:27

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/deletedat.go:

func() {
                pid := syscall.Getpid()
                _, err := utils.Catch(func() {
                        patches = gomonkey.ApplyMethod(gorm.SoftDeleteDeleteClause{},
                                "ModifyStatement", gormSoftDeleteDeleteClauseModifyStatement)
                        log.Printf("%v [Gofusion] %s patch gorm.SoftDeleteDeleteClause success", pid, config.ComponentDB)
                })
                if err != nil {
                        log.Printf("%v [Gofusion] %s patch gorm.SoftDeleteDeleteClause failed: %s",
                                pid, config.ComponentDB, errors.Cause(err))
                }
        }

func TimestampUpdateClause.ModifyStatement

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/timestamp.go:

func (t TimestampUpdateClause) ModifyStatement(stmt *gorm.Statement) {
        if stmt.SQL.Len() == 0 && !stmt.Statement.Unscoped {
                TimestampQueryClause(t).ModifyStatement(stmt)
        }
}

func @20:3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/types.go:

20	`func() (ok bool) { _, withSoftDelete = clauses[timestampEnabledFlag]; return withSoftDelete }`

func @24:25

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/deletedat.go:

func() {
                        patches = gomonkey.ApplyMethod(gorm.SoftDeleteDeleteClause{},
                                "ModifyStatement", gormSoftDeleteDeleteClauseModifyStatement)
                        log.Printf("%v [Gofusion] %s patch gorm.SoftDeleteDeleteClause success", pid, config.ComponentDB)
                }

func @18:3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/types.go:

18	`func() (ok bool) { _, withSoftDelete = clauses[defaultEnabledFlag]; return withSoftDelete }`

func IsClausesWithSoftDelete

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/types.go:

func IsClausesWithSoftDelete(clauses map[string]clause.Clause) (withSoftDelete bool) {
        utils.IfAny(
                func() (ok bool) { _, withSoftDelete = clauses[defaultEnabledFlag]; return withSoftDelete },
                func() (ok bool) { _, withSoftDelete = clauses[statusEnabledFlag]; return withSoftDelete },
                func() (ok bool) { _, withSoftDelete = clauses[timestampEnabledFlag]; return withSoftDelete },
                func() (ok bool) { _, withSoftDelete = clauses[deletedAtEnabledFlag]; return withSoftDelete },
        )
        return
}

func @21:3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/types.go:

21	`func() (ok bool) { _, withSoftDelete = clauses[deletedAtEnabledFlag]; return withSoftDelete }`

func deletedUpdateClause.ModifyStatement

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/deleted.go:

func (s deletedUpdateClause) ModifyStatement(stmt *gorm.Statement) {
        if stmt.SQL.Len() == 0 && !stmt.Statement.Unscoped {
                deletedQueryClause(s).ModifyStatement(stmt)
        }
}

func @19:3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/types.go:

19	`func() (ok bool) { _, withSoftDelete = clauses[statusEnabledFlag]; return withSoftDelete }`

func PatchGormDeleteAt

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/deletedat.go:

func PatchGormDeleteAt() (patches *gomonkey.Patches) {
        PatchGormDeleteAtOnce.Do(func() {
                pid := syscall.Getpid()
                _, err := utils.Catch(func() {
                        patches = gomonkey.ApplyMethod(gorm.SoftDeleteDeleteClause{},
                                "ModifyStatement", gormSoftDeleteDeleteClauseModifyStatement)
                        log.Printf("%v [Gofusion] %s patch gorm.SoftDeleteDeleteClause success", pid, config.ComponentDB)
                })
                if err != nil {
                        log.Printf("%v [Gofusion] %s patch gorm.SoftDeleteDeleteClause failed: %s",
                                pid, config.ComponentDB, errors.Cause(err))
                }
        })

        return
}

func Timestamp.UpdateClauses

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/timestamp.go:

88	`func (Timestamp) UpdateClauses(f *schema.Field) []clause.Interface {`
89	`return []clause.Interface{TimestampUpdateClause{Field: f, ZeroValue: parseTimestampZeroValueTag(f)}}`
90	`}`

func Timestamp.QueryClauses

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/timestamp.go:

49	`func (Timestamp) QueryClauses(f *schema.Field) []clause.Interface {`
50	`return []clause.Interface{TimestampQueryClause{Field: f, ZeroValue: parseTimestampZeroValueTag(f)}}`
51	`}`

func Timestamp.DeleteClauses

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/timestamp.go:

110	`func (Timestamp) DeleteClauses(f *schema.Field) []clause.Interface {`
111	`return []clause.Interface{TimestampDeleteClause{Field: f, ZeroValue: parseTimestampZeroValueTag(f)}}`
112	`}`

func Deleted.DeleteClauses

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/deleted.go:

109	`func (Deleted) DeleteClauses(f *schema.Field) []clause.Interface {`
110	`return []clause.Interface{deletedDeleteClause{Field: f, ZeroValue: parseStatusZeroValueTag(f)}}`
111	`}`

func Timestamp.Scan

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/timestamp.go:

19	`func (t *Timestamp) Scan(value any) error {`
20	`return (*sql.NullInt64)(t).Scan(value)`
21	`}`

func Deleted.QueryClauses

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/deleted.go:

47	`func (Deleted) QueryClauses(f *schema.Field) []clause.Interface {`
48	`return []clause.Interface{deletedQueryClause{Field: f, ZeroValue: parseStatusZeroValueTag(f)}}`
49	`}`

func Deleted.Value

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/deleted.go:

27	`func (s Deleted) Value() (driver.Value, error) {`
28	`return bool(s), nil`
29	`}`

func Deleted.UpdateClauses

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/deleted.go:

87	`func (Deleted) UpdateClauses(f *schema.Field) []clause.Interface {`
88	`return []clause.Interface{deletedUpdateClause{Field: f, ZeroValue: parseStatusZeroValueTag(f)}}`
89	`}`

func TimestampDeleteClause.ModifyStatement

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/timestamp.go:

func (t TimestampDeleteClause) ModifyStatement(stmt *gorm.Statement) {
        if stmt.Statement.Unscoped || stmt.SQL.Len() > 0 {
                return
        }

        curTimestamp := utils.GetTimeStamp(stmt.DB.NowFunc())
        setClauses := clause.Set{{Column: clause.Column{Name: t.Field.DBName}, Value: curTimestamp}}
        if clauses, ok := stmt.Clauses[setClauses.Name()]; ok {
                if exprClauses, ok := clauses.Expression.(clause.Set); ok {
                        setClauses = append(setClauses, exprClauses...)
                }
        }
        stmt.AddClause(setClauses)
        stmt.SetColumn(t.Field.DBName, curTimestamp, true)

        TimestampQueryClause(t).ModifyStatement(stmt)
}

func Deleted.Scan

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/deleted.go:

func (s *Deleted) Scan(value any) (err error) {
        var b bool
        if err = convertAssignRows(&b, value, nil); err != nil {
                return
        }
        *s = Deleted(b)
        return
}

func deletedQueryClause.ModifyStatement

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/deleted.go:

func (s deletedQueryClause) ModifyStatement(stmt *gorm.Statement) {
        if _, ok := stmt.Clauses[statusEnabledFlag]; ok || stmt.Statement.Unscoped {
                return
        }

        if c, ok := stmt.Clauses["WHERE"]; ok {
                if where, ok := c.Expression.(clause.Where); ok && len(where.Exprs) >= 1 {
                        for _, expr := range where.Exprs {
                                if orCond, ok := expr.(clause.OrConditions); ok && len(orCond.Exprs) == 1 {
                                        where.Exprs = []clause.Expression{clause.And(where.Exprs...)}
                                        c.Expression = where
                                        stmt.Clauses["WHERE"] = c
                                        break
                                }
                        }
                }
        }

        stmt.AddClause(clause.Where{Exprs: []clause.Expression{
                clause.Eq{Column: clause.Column{Table: clause.CurrentTable, Name: s.Field.DBName}, Value: s.ZeroValue},
        }})
        stmt.Clauses[statusEnabledFlag] = clause.Clause{}
}

func TimestampQueryClause.ModifyStatement

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/timestamp.go:

func (t TimestampQueryClause) ModifyStatement(stmt *gorm.Statement) {
        if _, ok := stmt.Clauses[timestampEnabledFlag]; ok || stmt.Statement.Unscoped {
                return
        }
        if c, ok := stmt.Clauses["WHERE"]; ok {
                if where, ok := c.Expression.(clause.Where); ok && len(where.Exprs) >= 1 {
                        for _, expr := range where.Exprs {
                                if orCond, ok := expr.(clause.OrConditions); ok && len(orCond.Exprs) == 1 {
                                        where.Exprs = []clause.Expression{clause.And(where.Exprs...)}
                                        c.Expression = where
                                        stmt.Clauses["WHERE"] = c
                                        break
                                }
                        }
                }
        }

        stmt.AddClause(clause.Where{Exprs: []clause.Expression{
                clause.Eq{Column: clause.Column{Table: clause.CurrentTable, Name: t.Field.DBName}, Value: t.ZeroValue},
        }})
        stmt.Clauses[timestampEnabledFlag] = clause.Clause{}
}

func Timestamp.Value

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/timestamp.go:

func (t Timestamp) Value() (driver.Value, error) {
        if !t.Valid {
                return nil, nil
        }
        return t.Int64, nil
}

func parseStatusZeroValueTag

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/deleted.go:

func parseStatusZeroValueTag(f *schema.Field) (s Deleted) {
        if v, ok := f.TagSettings["ZEROVALUE"]; ok {
                if vv, err := strconv.ParseBool(v); err == nil {
                        return Deleted(vv)
                }
        }
        return Deleted(false)
}

func parseTimestampZeroValueTag

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/timestamp.go:

func parseTimestampZeroValueTag(f *schema.Field) sql.NullInt64 {
        if v, ok := f.TagSettings["ZEROVALUE"]; ok {
                if vv, err := strconv.ParseInt(v, 10, 64); err == nil {
                        return sql.NullInt64{Int64: vv, Valid: true}
                }
        }
        return sql.NullInt64{Valid: false}
}

func gormSoftDeleteDeleteClauseModifyStatement

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/deletedat.go:

func gormSoftDeleteDeleteClauseModifyStatement(sd gorm.SoftDeleteDeleteClause, stmt *gorm.Statement) {
        if stmt.Statement.Unscoped || stmt.SQL.Len() > 0 {
                return
        }

        curTime := stmt.DB.NowFunc()
        setClauses := clause.Set{{Column: clause.Column{Name: sd.Field.DBName}, Value: curTime}}
        if clauses, ok := stmt.Clauses[setClauses.Name()]; ok {
                if exprClauses, ok := clauses.Expression.(clause.Set); ok {
                        setClauses = append(setClauses, exprClauses...)
                }
        }
        stmt.AddClause(setClauses)
        stmt.SetColumn(sd.Field.DBName, curTime, true)

        gorm.SoftDeleteQueryClause(sd).ModifyStatement(stmt)
}

func Timestamp.UnmarshalJSON

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/timestamp.go:

func (t *Timestamp) UnmarshalJSON(bs []byte) error {
        if string(bs) == "null" {
                t.Valid = false
                return nil
        }
        err := json.Unmarshal(bs, &t.Int64)
        if err == nil {
                t.Valid = true
        }
        return err
}

func Deleted.UnmarshalJSON

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/deleted.go:

func (s *Deleted) UnmarshalJSON(bs []byte) error {
        if string(bs) == "null" {
                return nil
        }
        var b bool
        err := json.Unmarshal(bs, &b)
        if err == nil {
                *s = Deleted(b)
        }

        return err
}

func Timestamp.MarshalJSON

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/timestamp.go:

func (t Timestamp) MarshalJSON() ([]byte, error) {
        if t.Valid {
                return json.Marshal(t.Int64)
        }
        return json.Marshal(nil)
}

func deletedQueryClause.Name

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/deleted.go:

56	`func (s deletedQueryClause) Name() string {`
57	`return ""`
58	`}`

func TimestampQueryClause.Name

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/timestamp.go:

58	`func (t TimestampQueryClause) Name() string {`
59	`return ""`
60	`}`

func deletedDeleteClause.Name

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/deleted.go:

118	`func (s deletedDeleteClause) Name() string {`
119	`return ""`
120	`}`

func TimestampDeleteClause.Name

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/timestamp.go:

119	`func (t TimestampDeleteClause) Name() string {`
120	`return ""`
121	`}`

func Deleted.MarshalJSON

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/deleted.go:

31	`func (s Deleted) MarshalJSON() ([]byte, error) {`
32	`return json.Marshal(bool(s))`
33	`}`

func deletedUpdateClause.Name

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/deleted.go:

96	`func (s deletedUpdateClause) Name() string {`
97	`return ""`
98	`}`

func TimestampUpdateClause.Name

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/timestamp.go:

97	`func (t TimestampUpdateClause) Name() string {`
98	`return ""`
99	`}`

func TimestampUpdateClause.MergeClause

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/timestamp.go:

102	`func (t TimestampUpdateClause) MergeClause(*clause.Clause) {`
103	`}`

func TimestampUpdateClause.Build

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/timestamp.go:

100	`func (t TimestampUpdateClause) Build(clause.Builder) {`
101	`}`

func deletedUpdateClause.Build

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/deleted.go:

99	`func (s deletedUpdateClause) Build(clause.Builder) {`
100	`}`

func TimestampDeleteClause.Build

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/timestamp.go:

122	`func (t TimestampDeleteClause) Build(clause.Builder) {`
123	`}`

func TimestampDeleteClause.MergeClause

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/timestamp.go:

124	`func (t TimestampDeleteClause) MergeClause(*clause.Clause) {`
125	`}`

func deletedQueryClause.MergeClause

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/deleted.go:

61	`func (s deletedQueryClause) MergeClause(*clause.Clause) {`
62	`}`

func TimestampQueryClause.MergeClause

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/timestamp.go:

63	`func (t TimestampQueryClause) MergeClause(*clause.Clause) {`
64	`}`

func TimestampQueryClause.Build

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/timestamp.go:

61	`func (t TimestampQueryClause) Build(clause.Builder) {`
62	`}`

func deletedUpdateClause.MergeClause

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/deleted.go:

101	`func (s deletedUpdateClause) MergeClause(*clause.Clause) {`
102	`}`

func deletedDeleteClause.Build

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/deleted.go:

121	`func (s deletedDeleteClause) Build(clause.Builder) {`
122	`}`

func deletedDeleteClause.MergeClause

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/deleted.go:

123	`func (s deletedDeleteClause) MergeClause(*clause.Clause) {`
124	`}`

func deletedQueryClause.Build

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/db/softdelete/deleted.go:

59	`func (s deletedQueryClause) Build(clause.Builder) {`
60	`}`

Package Overview: github.com/wfusion/gofusion/http 68.3%

Please select a function to see what's left for testing.

`lookupFieldByStruct(...)`	`github.com/wfusion/gofusion/http/router.go`	`100.0%`	`20/20`
`addClient(...)`	`github.com/wfusion/gofusion/http/construct.go`	`100.0%`	`14/14`
`Construct(...)`	`github.com/wfusion/gofusion/http/construct.go`	`100.0%`	`14/14`
`addI18n(...)`	`github.com/wfusion/gofusion/http/construct.go`	`100.0%`	`10/10`
`@223:9(...)`	`github.com/wfusion/gofusion/http/construct.go`	`100.0%`	`8/8`
`@177:9(...)`	`github.com/wfusion/gofusion/http/construct.go`	`100.0%`	`6/6`
`router.checkParamType(...)`	`github.com/wfusion/gofusion/http/router.go`	`100.0%`	`4/4`
`@498:8(...)`	`github.com/wfusion/gofusion/http/router.go`	`100.0%`	`3/3`
`router.Any(...)`	`github.com/wfusion/gofusion/http/router.go`	`100.0%`	`3/3`
`router.rspError(...)`	`github.com/wfusion/gofusion/http/router.go`	`100.0%`	`3/3`
`router.wrapHandlerFunc(...)`	`github.com/wfusion/gofusion/http/router.go`	`100.0%`	`3/3`
`router.Config(...)`	`github.com/wfusion/gofusion/http/router.go`	`100.0%`	`3/3`
`router.POST(...)`	`github.com/wfusion/gofusion/http/router.go`	`100.0%`	`3/3`
`router.GET(...)`	`github.com/wfusion/gofusion/http/router.go`	`100.0%`	`3/3`
`@445:8(...)`	`github.com/wfusion/gofusion/http/router.go`	`100.0%`	`3/3`
`@62:9(...)`	`github.com/wfusion/gofusion/http/construct.go`	`100.0%`	`3/3`
`router.rspSuccess(...)`	`github.com/wfusion/gofusion/http/router.go`	`100.0%`	`3/3`
`@63:23(...)`	`github.com/wfusion/gofusion/http/zerocopy.go`	`100.0%`	`2/2`
`ContentZeroCopy(...)`	`github.com/wfusion/gofusion/http/zerocopy.go`	`100.0%`	`2/2`
`@636:4(...)`	`github.com/wfusion/gofusion/http/router.go`	`100.0%`	`2/2`
`@637:4(...)`	`github.com/wfusion/gofusion/http/router.go`	`100.0%`	`2/2`
`@140:8(...)`	`github.com/wfusion/gofusion/http/construct.go`	`100.0%`	`2/2`
`@311:10(...)`	`github.com/wfusion/gofusion/http/router.go`	`100.0%`	`2/2`
`StaticFileZeroCopy(...)`	`github.com/wfusion/gofusion/http/zerocopy.go`	`100.0%`	`2/2`
`router.StaticFile(...)`	`github.com/wfusion/gofusion/http/router.go`	`100.0%`	`2/2`
`@174:22(...)`	`github.com/wfusion/gofusion/http/construct.go`	`100.0%`	`1/1`
`router.Group(...)`	`github.com/wfusion/gofusion/http/router.go`	`100.0%`	`1/1`
`@753:42(...)`	`github.com/wfusion/gofusion/http/router.go`	`100.0%`	`1/1`
`router.Closing(...)`	`github.com/wfusion/gofusion/http/router.go`	`100.0%`	`1/1`
`@243:9(...)`	`github.com/wfusion/gofusion/http/construct.go`	`100.0%`	`1/1`
`AppName(...)`	`github.com/wfusion/gofusion/http/construct.go`	`100.0%`	`1/1`
`init(...)`	`github.com/wfusion/gofusion/http/construct.go`	`100.0%`	`1/1`
`router.Running(...)`	`github.com/wfusion/gofusion/http/router.go`	`100.0%`	`1/1`
`init(...)`	`github.com/wfusion/gofusion/http/client.go`	`100.0%`	`1/1`
`asynqRedisConnOpt.MakeRedisClient(...)`	`github.com/wfusion/gofusion/http/asynq.go`	`100.0%`	`1/1`
`router.Use(...)`	`github.com/wfusion/gofusion/http/router.go`	`100.0%`	`1/1`
`NewRequest(...)`	`github.com/wfusion/gofusion/http/client.go`	`100.0%`	`1/1`
`router.ServeHTTP(...)`	`github.com/wfusion/gofusion/http/router.go`	`100.0%`	`1/1`
`@522:4(...)`	`github.com/wfusion/gofusion/http/router.go`	`100.0%`	`1/1`
`@521:4(...)`	`github.com/wfusion/gofusion/http/router.go`	`100.0%`	`1/1`
`Errcode.String(...)`	`github.com/wfusion/gofusion/http/error.go`	`100.0%`	`1/1`
`@22:9(...)`	`github.com/wfusion/gofusion/http/zerocopy.go`	`100.0%`	`1/1`
`@460:8(...)`	`github.com/wfusion/gofusion/http/router.go`	`100.0%`	`1/1`
`@37:9(...)`	`github.com/wfusion/gofusion/http/client.go`	`100.0%`	`1/1`
`CName(...)`	`github.com/wfusion/gofusion/http/client.go`	`100.0%`	`1/1`
`newRouter(...)`	`github.com/wfusion/gofusion/http/router.go`	`100.0%`	`1/1`
`rspSuccess(...)`	`github.com/wfusion/gofusion/http/response.go`	`90.9%`	`10/11`
`useClient(...)`	`github.com/wfusion/gofusion/http/client.go`	`90.0%`	`9/10`
`addRouter(...)`	`github.com/wfusion/gofusion/http/construct.go`	`88.5%`	`23/26`
`router.parseReqFromQuery(...)`	`github.com/wfusion/gofusion/http/router.go`	`88.2%`	`15/17`
`router.shutdown(...)`	`github.com/wfusion/gofusion/http/router.go`	`87.5%`	`7/8`
`New(...)`	`github.com/wfusion/gofusion/http/client.go`	`87.1%`	`27/31`
`router.convert(...)`	`github.com/wfusion/gofusion/http/router.go`	`86.7%`	`13/15`
`router.Start(...)`	`github.com/wfusion/gofusion/http/router.go`	`85.7%`	`12/14`
`lookupFieldByMap(...)`	`github.com/wfusion/gofusion/http/router.go`	`85.7%`	`6/7`
`Use(...)`	`github.com/wfusion/gofusion/http/construct.go`	`85.7%`	`6/7`
`router.rspEmbed(...)`	`github.com/wfusion/gofusion/http/router.go`	`82.4%`	`14/17`
`rspError(...)`	`github.com/wfusion/gofusion/http/response.go`	`81.8%`	`9/11`
`@132:9(...)`	`github.com/wfusion/gofusion/http/construct.go`	`80.0%`	`12/15`
`router.use(...)`	`github.com/wfusion/gofusion/http/router.go`	`80.0%`	`4/5`
`router.parseReqFromBody(...)`	`github.com/wfusion/gofusion/http/router.go`	`79.2%`	`19/24`
`@539:9(...)`	`github.com/wfusion/gofusion/http/router.go`	`76.9%`	`20/26`
`initAsynq(...)`	`github.com/wfusion/gofusion/http/asynq.go`	`75.0%`	`6/8`
`lookupFieldByValue(...)`	`github.com/wfusion/gofusion/http/router.go`	`75.0%`	`3/4`
`router.convertMulti(...)`	`github.com/wfusion/gofusion/http/router.go`	`71.4%`	`5/7`
`metricsCode(...)`	`github.com/wfusion/gofusion/http/metrics.go`	`69.2%`	`9/13`
`traceHeaderMiddleware(...)`	`github.com/wfusion/gofusion/http/client.go`	`66.7%`	`4/6`
`router.checkHandlerType(...)`	`github.com/wfusion/gofusion/http/router.go`	`63.2%`	`12/19`
`ginZeroCopyWriter.ReadFrom(...)`	`github.com/wfusion/gofusion/http/zerocopy.go`	`62.5%`	`10/16`
`parseRspError(...)`	`github.com/wfusion/gofusion/http/router.go`	`62.5%`	`5/8`
`parseRspSuccess(...)`	`github.com/wfusion/gofusion/http/router.go`	`58.3%`	`7/12`
`transformData(...)`	`github.com/wfusion/gofusion/http/router.go`	`57.1%`	`4/7`
`@30:9(...)`	`github.com/wfusion/gofusion/http/zerocopy.go`	`50.0%`	`4/8`
`embedResponse(...)`	`github.com/wfusion/gofusion/http/response.go`	`50.0%`	`3/6`
`router.useIRouter(...)`	`github.com/wfusion/gofusion/http/router.go`	`40.0%`	`2/5`
`applyClientOptions(...)`	`github.com/wfusion/gofusion/http/client.go`	`23.1%`	`3/13`
`router.ListenAndServe(...)`	`github.com/wfusion/gofusion/http/router.go`	`0.0%`	`0/16`
`langs(...)`	`github.com/wfusion/gofusion/http/response.go`	`0.0%`	`0/8`
`Localizable(...)`	`github.com/wfusion/gofusion/http/i18n.go`	`0.0%`	`0/7`
`@101:17(...)`	`github.com/wfusion/gofusion/http/construct.go`	`0.0%`	`0/5`
`@92:18(...)`	`github.com/wfusion/gofusion/http/construct.go`	`0.0%`	`0/5`
`ErrCtx(...)`	`github.com/wfusion/gofusion/http/error.go`	`0.0%`	`0/4`
`Err(...)`	`github.com/wfusion/gofusion/http/error.go`	`0.0%`	`0/4`
`router.Handle(...)`	`github.com/wfusion/gofusion/http/router.go`	`0.0%`	`0/3`
`bizErr.Error(...)`	`github.com/wfusion/gofusion/http/error.go`	`0.0%`	`0/3`
`router.HEAD(...)`	`github.com/wfusion/gofusion/http/router.go`	`0.0%`	`0/3`
`router.PATCH(...)`	`github.com/wfusion/gofusion/http/router.go`	`0.0%`	`0/3`
`router.DELETE(...)`	`github.com/wfusion/gofusion/http/router.go`	`0.0%`	`0/3`
`@43:9(...)`	`github.com/wfusion/gofusion/http/client.go`	`0.0%`	`0/3`
`@51:9(...)`	`github.com/wfusion/gofusion/http/client.go`	`0.0%`	`0/3`
`router.PUT(...)`	`github.com/wfusion/gofusion/http/router.go`	`0.0%`	`0/3`
`router.OPTIONS(...)`	`github.com/wfusion/gofusion/http/router.go`	`0.0%`	`0/3`
`router.StaticFileFS(...)`	`github.com/wfusion/gofusion/http/router.go`	`0.0%`	`0/2`
`router.Static(...)`	`github.com/wfusion/gofusion/http/router.go`	`0.0%`	`0/2`
`router.StaticFS(...)`	`github.com/wfusion/gofusion/http/router.go`	`0.0%`	`0/2`
`@185:8(...)`	`github.com/wfusion/gofusion/http/router.go`	`0.0%`	`0/2`
`@71:8(...)`	`github.com/wfusion/gofusion/http/zerocopy.go`	`0.0%`	`0/2`
`Langs(...)`	`github.com/wfusion/gofusion/http/error.go`	`0.0%`	`0/1`
`@129:22(...)`	`github.com/wfusion/gofusion/http/construct.go`	`0.0%`	`0/1`
`@219:23(...)`	`github.com/wfusion/gofusion/http/construct.go`	`0.0%`	`0/1`
`Errcode.Error(...)`	`github.com/wfusion/gofusion/http/error.go`	`0.0%`	`0/1`
`@37:9(...)`	`github.com/wfusion/gofusion/http/error.go`	`0.0%`	`0/1`
`@797:9(...)`	`github.com/wfusion/gofusion/http/router.go`	`0.0%`	`0/1`
`ParseFromQuery(...)`	`github.com/wfusion/gofusion/http/router.go`	`0.0%`	`0/1`
`@803:9(...)`	`github.com/wfusion/gofusion/http/router.go`	`0.0%`	`0/1`
`HandleBefore(...)`	`github.com/wfusion/gofusion/http/router.go`	`0.0%`	`0/1`
`@809:9(...)`	`github.com/wfusion/gofusion/http/router.go`	`0.0%`	`0/1`
`HandleAfter(...)`	`github.com/wfusion/gofusion/http/router.go`	`0.0%`	`0/1`
`@815:9(...)`	`github.com/wfusion/gofusion/http/router.go`	`0.0%`	`0/1`
`Param(...)`	`github.com/wfusion/gofusion/http/error.go`	`0.0%`	`0/1`
`RetryHook(...)`	`github.com/wfusion/gofusion/http/client.go`	`0.0%`	`0/1`
`@43:9(...)`	`github.com/wfusion/gofusion/http/error.go`	`0.0%`	`0/1`
`ParseFromBody(...)`	`github.com/wfusion/gofusion/http/router.go`	`0.0%`	`0/1`
`Msg(...)`	`github.com/wfusion/gofusion/http/error.go`	`0.0%`	`0/1`
`RetryCondition(...)`	`github.com/wfusion/gofusion/http/client.go`	`0.0%`	`0/1`
`@49:9(...)`	`github.com/wfusion/gofusion/http/error.go`	`0.0%`	`0/1`

func lookupFieldByStruct

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func lookupFieldByStruct(rspStruct reflect.Value) (data any, page, count int, msg string) {
        var (
                routerResponsePageName = map[string]bool{
                        "page": true,
                        "Page": true,
                }
                routerResponseCountName = map[string]bool{
                        "count": true,
                        "Count": true,
                }
                routerResponseDataName = map[string]bool{
                        "data": true,
                        "Data": true,
                }
                routerResponseMsgName = map[string]bool{
                        "msg":     true,
                        "Msg":     true,
                        "message": true,
                        "Message": true,
                }
        )

        type lookupFunc func(v reflect.Value, keywords map[string]bool) (reflect.Value, bool)
        lookupFuncMap := map[reflect.Kind]lookupFunc{
                reflect.Map:    lookupFieldByMap,
                reflect.Struct: lookupFieldByValue,
        }

        rsp := utils.IndirectValue(rspStruct)
        lookup, ok := lookupFuncMap[rsp.Kind()]
        if !ok {
                data = rspStruct.Interface()
                return
        }

        // cannot parse response.Data, resolve all rspStruct as data
        if dataValue, ok := lookup(rsp, routerResponseDataName); ok {
                if dataValue.IsValid() {
                        data = transformData(reflect.ValueOf(valueInterface(dataValue, false)))
                }
        } else {
                data = rspStruct.Interface()
                return
        }
        if pageValue, ok := lookup(rsp, routerResponsePageName); ok && pageValue.IsValid() {
                page = cast.ToInt(pageValue.Int())
        }
        if countValue, ok := lookup(rsp, routerResponseCountName); ok && countValue.IsValid() {
                count = cast.ToInt(countValue.Int())
        }
        if msgValue, ok := lookup(rsp, routerResponseMsgName); ok && msgValue.IsValid() {
                msg = msgValue.String()
        }

        return
}

func addClient

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/construct.go:

func addClient(ctx context.Context, conf Conf, logger resty.Logger, opt *config.InitOption) func() {
        if _, ok := appClientCfgMap[opt.AppName]; !ok {
                defaultCfg := &cfg{
                        c:       clone.Clone(defaultClientConf),
                        appName: opt.AppName,
                        logger:  logger,
                }
                appClientCfgMap[opt.AppName] = map[string]*cfg{
                        "":        defaultCfg,
                        "default": defaultCfg,
                }
        }
        for name, cliConf := range conf.Clients {
                cliCfg := &cfg{
                        c:       cliConf,
                        appName: opt.AppName,
                        logger:  logger,
                }
                appClientCfgMap[opt.AppName][name] = cliCfg
                if name == config.DefaultInstanceKey {
                        appClientCfgMap[opt.AppName][""] = cliCfg
                }

                if opt.AppName == "" && name == config.DefaultInstanceKey {
                        Client = New(AppName(opt.AppName), CName(name))
                }
        }

        if opt.DI != nil {
                for name := range conf.Clients {
                        opt.DI.MustProvide(func() *resty.Client { return New(AppName(opt.AppName), CName(name)) }, di.Name(name))
                }
        }

        return func() {
                locker.Lock()
                defer locker.Unlock()
                if appClientMap != nil {
                        delete(appClientMap, opt.AppName)
                }
                if appClientCfgMap != nil {
                        delete(appClientCfgMap, opt.AppName)
                }
                if opt.AppName == "" {
                        Client = nil
                }
        }
}

func Construct

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/construct.go:

func Construct(ctx context.Context, conf Conf, opts ...utils.OptionExtender) func() {
        opt := utils.ApplyOptions[config.InitOption](opts...)
        optU := utils.ApplyOptions[useOption](opts...)
        if opt.AppName == "" {
                opt.AppName = optU.appName
        }

        var logger resty.Logger
        if utils.IsStrNotBlank(conf.Logger) {
                logger = reflect.New(inspect.TypeOf(conf.Logger)).Interface().(resty.Logger)
                if custom, ok := logger.(customLogger); ok {
                        l := fusLog.Use(conf.LogInstance, fusLog.AppName(opt.AppName))
                        custom.Init(l, opt.AppName)
                }
        }

        exitRouterFn := addRouter(ctx, conf, logger, opt)
        exitI18nFn := addI18n(opt)
        exitClientFn := addClient(ctx, conf, logger, opt)

        // gracefully exit outside gofusion
        return func() {
                exitClientFn()
                exitRouterFn()
                exitI18nFn()
        }
}

func addI18n

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/construct.go:

func addI18n(opt *config.InitOption) func() {
        bundle := i18n.NewBundle[Errcode](i18n.DefaultLang(i18n.AppName(opt.AppName)))
        if I18n == nil {
                I18n = bundle
        }
        if i18ns == nil {
                i18ns = make(map[string]i18n.Localizable[Errcode])
        }

        i18ns[opt.AppName] = bundle

        // initialize http internal error
        bundle.AddMessages(errParam, map[language.Tag]*i18n.Message{
                language.English: {Other: "Invalid request parameters{{.err}}"},
                language.Chinese: {Other: "请求参数错误{{.err}}"},
        }, i18n.Var("err"))

        if opt.DI != nil {
                opt.DI.MustProvide(func() i18n.Localizable[Errcode] { return bundle })
        }

        return func() {
                locker.Lock()
                defer locker.Unlock()
                if i18ns != nil {
                        delete(i18ns, opt.AppName)
                }
                if opt.AppName == "" {
                        I18n = nil
                }
        }
}

func @223:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/construct.go:

func() {
                locker.Lock()
                defer locker.Unlock()
                if appClientMap != nil {
                        delete(appClientMap, opt.AppName)
                }
                if appClientCfgMap != nil {
                        delete(appClientCfgMap, opt.AppName)
                }
                if opt.AppName == "" {
                        Client = nil
                }
        }

func @177:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/construct.go:

func() {
                locker.Lock()
                defer locker.Unlock()
                if i18ns != nil {
                        delete(i18ns, opt.AppName)
                }
                if opt.AppName == "" {
                        I18n = nil
                }
        }

func router.checkParamType

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func (r *router) checkParamType(typ reflect.Type, supportType map[reflect.Kind]struct{}) bool {
        if typ.Kind() == reflect.Ptr {
                typ = typ.Elem()
        }
        _, ok := supportType[typ.Kind()]
        return ok
}

func @498:8

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func() {
                for ptrDepth > 0 {
                        dst = dst.Addr()
                        ptrDepth--
                }
        }

func router.Any

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func (r *router) Any(uri string, fn routerHandler, opts ...utils.OptionExtender) IRouter {
        opt := utils.ApplyOptions[routerOption](opts...)
        r.use().Any(uri, r.convertMulti("Any", uri, fn, opt)...)
        return r
}

func router.rspError

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func (r *router) rspError(c *gin.Context, rspVals []reflect.Value, err error) {
        code, data, page, count, msg := parseRspError(rspVals, err)
        rspError(c, r.appName, code, data, page, count, msg)

        go metricsCode(r.ctx, r.appName, c.Request.URL.Path, c.Request.Method, cast.ToInt(code),
                c.Writer.Status(), c.Writer.Size(), c.Request.ContentLength)
}

func router.wrapHandlerFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func (r *router) wrapHandlerFunc(handler routerHandler, reqParse routerRequestParser) gin.HandlerFunc {
        typ := reflect.TypeOf(handler)
        numOut := typ.NumOut()
        return func(c *gin.Context) {
                var (
                        err     error
                        reqVal  reflect.Value
                        rspVals []reflect.Value
                )

                // deal with request & call handler
                if reqParse == nil {
                        rspVals = reflect.ValueOf(handler).Call([]reflect.Value{reflect.ValueOf(c)})
                } else if reqVal, err = reqParse(c, typ.In(1)); err == nil {
                        rspVals = reflect.ValueOf(handler).Call([]reflect.Value{reflect.ValueOf(c), reqVal})
                } else {
                        switch e := err.(type) {
                        case *json.UnmarshalTypeError:
                                msg := fmt.Sprintf(": %s field type should be %s", e.Value, e.Type.String())
                                r.rspError(c, nil, Err(c, errParam, Param(map[string]any{"err": msg})))
                        default:
                                r.rspError(c, nil, Err(c, errParam,
                                        Param(map[string]any{"err": fmt.Sprintf(": %s", err.Error())})))
                        }
                        c.Next()
                        return
                }

                // deal with response
                errVal := rspVals[numOut-1]
                if !errVal.IsNil() {
                        err = errVal.Interface().(error)
                }
                rspVals = rspVals[:numOut-1]

                var rspType reflect.Type
                isEmbed, isResponse := false, false
                if len(rspVals) > 0 {
                        rspType = utils.IndirectType(rspVals[0].Type())
                        isEmbed = utils.EmbedsType(rspType, embedType)
                        isResponse = utils.EmbedsType(rspType, responseType)
                }

                switch {
                case isEmbed, isResponse:
                        r.rspEmbed(c, rspVals[0], rspType, err) // directly json marshal embed response
                case err != nil:
                        r.rspError(c, rspVals, err) // business error
                default:
                        r.rspSuccess(c, rspVals) // success with response
                }

                c.Next()
        }
}

func router.Config

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func (r *router) Config() OutputConf {
        cfg := new(Conf)
        _ = config.Use(r.appName).LoadComponentConfig(config.ComponentHttp, cfg)

        return OutputConf{
                Port:         cfg.Port,
                TLS:          cfg.TLS,
                Cert:         cfg.Cert,
                Key:          cfg.Key,
                NextProtos:   cfg.NextProtos,
                SuccessCode:  cfg.SuccessCode,
                ReadTimeout:  utils.Must(time.ParseDuration(cfg.ReadTimeout)),
                WriteTimeout: utils.Must(time.ParseDuration(cfg.WriteTimeout)),
                AsynqConf:    clone.Slowly(cfg.Asynq),
        }
}

func router.POST

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func (r *router) POST(uri string, fn routerHandler, opts ...utils.OptionExtender) IRouter {
        opt := utils.ApplyOptions[routerOption](opts...)
        r.use().POST(uri, r.convertMulti(http.MethodPost, uri, fn, opt)...)
        return r
}

func router.GET

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func (r *router) GET(uri string, fn routerHandler, opts ...utils.OptionExtender) IRouter {
        opt := utils.ApplyOptions[routerOption](opts...)
        r.use().GET(uri, r.convertMulti(http.MethodGet, uri, fn, opt)...)
        return r
}

func @445:8

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func() {
                for ptrDepth > 0 {
                        dst = dst.Addr()
                        ptrDepth--
                }
        }

func @62:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/construct.go:

func() {
                exitClientFn()
                exitRouterFn()
                exitI18nFn()
        }

func router.rspSuccess

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func (r *router) rspSuccess(c *gin.Context, rspVals []reflect.Value) {
        data, page, count, msg := parseRspSuccess(rspVals)
        rspSuccess(c, r.successCode, data, page, count, msg)

        go metricsCode(r.ctx, r.appName, c.Request.URL.Path, c.Request.Method, r.successCode,
                c.Writer.Status(), c.Writer.Size(), c.Request.ContentLength)
}

func @63:23

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/zerocopy.go:

63	`func() (err error) { conn, _, err = z.ResponseWriter.Hijack(); return }`

func ContentZeroCopy

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/zerocopy.go:

func ContentZeroCopy(fn getContentFn, opts ...utils.OptionExtender) func(c *gin.Context) {
        opt := utils.ApplyOptions[useOption](opts...)
        return func(c *gin.Context) {
                name, modTime, content, err := fn(c)
                if err != nil {
                        code, data, page, count, msg := parseRspError(nil, err)
                        rspError(c, opt.appName, code, data, page, count, msg)
                        c.Abort()
                        return
                }
                defer utils.CloseAnyway(content)
                http.ServeContent(&ginZeroCopyWriter{ResponseWriter: c.Writer, ctx: c}, c.Request, name, modTime, content)
        }
}

func @636:4

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

636	`func() (ok bool) { code, ok = rspData["code"]; return ok }`

func @637:4

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

637	`func() (ok bool) { code, ok = rspData["Code"]; return ok }`

func @140:8

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/construct.go:

140	`func() { defer wg.Done(); <-router.Closing() }`

func @311:10

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

311	`func(c *gin.Context) {`
312	`reflect.ValueOf(handler).Call([]reflect.Value{reflect.ValueOf(c)})`
313	`c.Next()`
314	`}`

func StaticFileZeroCopy

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/zerocopy.go:

func StaticFileZeroCopy(filename string) func(c *gin.Context) {
        filename = path.Clean(filename)
        return func(c *gin.Context) {
                http.ServeFile(&ginZeroCopyWriter{ResponseWriter: c.Writer, ctx: c}, c.Request, filename)
        }
}

func router.StaticFile

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

154	`func (r *router) StaticFile(uri, file string) IRouter { r.use().StaticFile(uri, file); return r }`

func @174:22

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/construct.go:

174	`func() i18n.Localizable[Errcode] { return bundle }`

func router.Group

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func (r *router) Group(relativePath string, handlers ...gin.HandlerFunc) IRouter {
        return &router{
                IRouter:     r.IRouter,
                open:        r.open,
                close:       r.close,
                ctx:         r.ctx,
                appName:     r.appName,
                successCode: r.successCode,
                routes:      r.routes,
                group:       r.useIRouter().Group(relativePath, handlers...),
                ptr:         dispatchGroup,
        }
}

func @753:42

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

753	`func(s string) bool { return keywords[s] }`

func router.Closing

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

234	`func (r *router) Closing() <-chan struct{} { return r.close }`

func @243:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/construct.go:

243	`func(o *useOption) {`
244	`o.appName = name`
245	`}`

func AppName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/construct.go:

func AppName(name string) utils.OptionFunc[useOption] {
        return func(o *useOption) {
                o.appName = name
        }
}

func init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/construct.go:

260	`func init() {`
261	`config.AddComponent(config.ComponentHttp, Construct)`
262	`}`

func router.Running

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

233	`func (r *router) Running() <-chan struct{} { return r.open }`

func init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/client.go:

func init() {
        _ = utils.ParseTag(defaultClientConf,
                utils.ParseTagName("default"),
                utils.ParseTagUnmarshalType(utils.UnmarshalTypeYaml))
}

func asynqRedisConnOpt.MakeRedisClient

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/asynq.go:

42	`func (a *asynqRedisConnOpt) MakeRedisClient() any { return a.UniversalClient }`

func router.Use

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func (r *router) Use(middlewares ...gin.HandlerFunc) IRouter {
        return &router{
                IRouter:     r.IRouter,
                open:        r.open,
                close:       r.close,
                ctx:         r.ctx,
                appName:     r.appName,
                successCode: r.successCode,
                routes:      r.use().Use(middlewares...),
                group:       r.group,
                ptr:         dispatchRoutes,
        }
}

func NewRequest

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/client.go:

130	`func NewRequest(ctx context.Context, opts ...utils.OptionExtender) *resty.Request {`
131	`return New(opts...).R().SetContext(ctx)`
132	`}`

func router.ServeHTTP

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

165	`func (r router) ServeHTTP(w http.ResponseWriter, req http.Request) {`
166	`r.IRouter.(*gin.Engine).ServeHTTP(w, req)`
167	`}`

func @522:4

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

522	`func() error { return parser.MapFormByTag(dst.Addr().Interface(), c.Request.URL.Query(), "json") }`

func @521:4

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

521	`func() error { return parser.MapFormByTag(dst.Addr().Interface(), m, "json") }`

func Errcode.String

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/error.go:

23	`func (e Errcode) String() (r string) {`
24	`return strconv.Itoa(int(e))`
25	`}`

func @22:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/zerocopy.go:

22	`func(c *gin.Context) {`
23	`http.ServeFile(&ginZeroCopyWriter{ResponseWriter: c.Writer, ctx: c}, c.Request, filename)`
24	`}`

func @460:8

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

460	`func() { c.Request.Body = io.NopCloser(bytes.NewBuffer(bodyBytes)) }`

func @37:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/client.go:

37	`func(o *clientOption) {`
38	`o.name = name`
39	`}`

func CName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/client.go:

func CName(name string) utils.OptionFunc[clientOption] {
        return func(o *clientOption) {
                o.name = name
        }
}

func newRouter

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func newRouter(ctx context.Context, r gin.IRouter, appName string, successCode int) IRouter {
        return &router{
                IRouter:     r,
                ctx:         ctx,
                open:        make(chan struct{}),
                close:       make(chan struct{}),
                appName:     appName,
                successCode: successCode,
        }
}

func rspSuccess

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/response.go:

func rspSuccess(c *gin.Context, code int, data any, page, count int, msg string) {
        status := c.Writer.Status()
        if status <= 0 {
                status = http.StatusOK
        }
        if msg == "" {
                msg = "ok"
        }
        var (
                pagePtr  *int
                countPtr *int
        )
        if page > 0 {
                pagePtr = utils.AnyPtr(page)
        }
        if count >= 0 {
                countPtr = utils.AnyPtr(count)
        }

        c.PureJSON(status, &Response{
                Code:    code,
                Message: msg,
                Data:    data,
                Page:    pagePtr,
                Count:   countPtr,
                TraceID: c.GetString(fusCtx.KeyTraceID),
        })
}

func useClient

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/client.go:

func useClient(opts ...utils.OptionExtender) (cli *resty.Client) {
        locker.RLock()
        defer locker.RUnlock()

        opt := utils.ApplyOptions[clientOption](opts...)
        opt.appName = utils.ApplyOptions[useOption](opts...).appName
        locker.RLock()
        defer locker.RUnlock()
        appClients, ok := appClientMap[opt.appName]
        if !ok {
                return
        }
        return appClients[opt.name]
}

func addRouter

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/construct.go:

func addRouter(ctx context.Context, conf Conf, logger resty.Logger, opt *config.InitOption) func() {
        engine := gin.New()
        engine.Use(
                gin.Recovery(),
                middleware.Gateway,
                middleware.Trace(),
                middleware.Logging(ctx, opt.AppName, logger),
                middleware.Cors(),
                middleware.XSS(conf.XSSWhiteURLList),
                middleware.Recover(opt.AppName, logger),
        )
        if config.Use(opt.AppName).Debug() {
                gin.SetMode(gin.DebugMode)
        } else {
                gin.SetMode(gin.ReleaseMode)
        }
        if !conf.ColorfulConsole {
                gin.DisableConsoleColor()
        } else {
                gin.ForceConsoleColor()
        }

        tag := i18n.DefaultLang(i18n.AppName(opt.AppName))
        engine.NoMethod(func(c *gin.Context) {
                c.Status(http.StatusMethodNotAllowed)
                msg := fmt.Sprintf("找不到该方法, Method: %s", c.Request.Method)
                if tag != language.Chinese {
                        msg = fmt.Sprintf("Cannot find method: %s", c.Request.Method)
                }

                rspError(c, opt.AppName, -1, nil, 0, 0, msg)
        })
        engine.NoRoute(func(c *gin.Context) {
                c.Status(http.StatusNotFound)
                msg := fmt.Sprintf("找不到该内容, URL: %s", c.Request.URL.String())
                if tag != language.Chinese {
                        msg = fmt.Sprintf("Cannot find URL content: %s", c.Request.URL.String())
                }
                rspError(c, opt.AppName, -1, nil, 0, 0, msg)
        })

        if conf.Pprof {
                pprof.Register(engine)
        }
        instance := newRouter(ctx, engine, opt.AppName, conf.SuccessCode)

        locker.Lock()
        defer locker.Unlock()
        if len(conf.Asynq) > 0 {
                initAsynq(ctx, opt.AppName, instance, conf.Asynq)
        }
        if _, ok := routers[opt.AppName]; ok {
                panic(errors.Errorf("duplicated http name: %s", opt.AppName))
        }
        routers[opt.AppName] = instance
        if opt.AppName == "" {
                Router = instance
        }

        if opt.DI != nil {
                opt.DI.MustProvide(func() IRouter { return Use(AppName(opt.AppName)) })
        }

        return func() {
                locker.Lock()
                defer locker.Unlock()
                if routers != nil {
                        if router, ok := routers[opt.AppName]; ok {
                                router.shutdown()
                                wg := new(sync.WaitGroup)
                                wg.Add(1)
                                go func() { defer wg.Done(); <-router.Closing() }()
                                if utils.Timeout(15*time.Second, utils.TimeoutWg(wg)) {
                                        pid := syscall.Getpid()
                                        app := config.Use(opt.AppName).AppName()
                                        log.Printf("%v [Gofusion] %s %s close http server timeout", pid, app, config.ComponentHttp)
                                }
                        }

                        delete(routers, opt.AppName)
                }
                if opt.AppName == "" {
                        Router = nil
                }
        }
}

func router.parseReqFromQuery

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func (r *router) parseReqFromQuery(c *gin.Context, typ reflect.Type) (dst reflect.Value, err error) {
        ptrDepth := 0
        for typ.Kind() == reflect.Ptr {
                typ = typ.Elem()
                ptrDepth++
        }
        defer func() {
                for ptrDepth > 0 {
                        dst = dst.Addr()
                        ptrDepth--
                }
        }()

        dst = reflect.Indirect(reflect.New(typ))
        if err = c.ShouldBindUri(dst.Addr().Interface()); err != nil &&
                !(errors.Is(err, binding.ErrConvertToMapString) || (errors.Is(err, binding.ErrConvertMapStringSlice))) {
                return
        }
        if err = c.ShouldBindQuery(dst.Addr().Interface()); err != nil &&
                !(errors.Is(err, binding.ErrConvertToMapString) || (errors.Is(err, binding.ErrConvertMapStringSlice))) {
                return
        }
        // support query with json tag
        if dst.IsZero() {
                m := make(map[string][]string)
                for _, v := range c.Params {
                        m[v.Key] = []string{v.Value}
                }
                err = utils.CheckIfAny(
                        func() error { return parser.MapFormByTag(dst.Addr().Interface(), m, "json") },
                        func() error { return parser.MapFormByTag(dst.Addr().Interface(), c.Request.URL.Query(), "json") },
                )
        }

        // parse default tag
        err = utils.ParseTag(
                dst.Addr().Interface(),
                utils.ParseTagName("default"),
                utils.ParseTagUnmarshalType(utils.UnmarshalTypeYaml),
        )

        return
}

func router.shutdown

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func (r *router) shutdown() {
        if r.close != nil {
                if _, ok := utils.IsChannelClosed(r.close); ok {
                        return
                }
        }
        if r.shutdownFunc != nil {
                r.shutdownFunc()
        }
        if r.close != nil {
                close(r.close)
        }

        r.open = make(chan struct{})
}

func New

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/client.go:

func New(opts ...utils.OptionExtender) *resty.Client {
        opt := utils.ApplyOptions[clientOption](opts...)
        opt.appName = utils.ApplyOptions[useOption](opts...).appName

        cli := useClient(opts...)
        if cli != nil {
                return applyClientOptions(cli, opt)
        }

        locker.Lock()
        defer locker.Unlock()

        c := resty.New().
                OnBeforeRequest(traceHeaderMiddleware).
                SetTransport(http.DefaultTransport).
                SetJSONMarshaler(json.Marshal).
                SetJSONUnmarshaler(json.Unmarshal).
                SetDebug(true)

        cfg, ok := appClientCfgMap[opt.appName][opt.name]
        if !ok {
                cfg = appClientCfgMap[opt.appName][config.DefaultInstanceKey]
        }

        if cfg.logger != nil {
                c.SetLogger(cfg.logger)
        }

        if cliCfg := cfg.c; cliCfg == nil || !cliCfg.Mock {
                c.EnableTrace()
        } else {
                c.SetTimeout(utils.Must(time.ParseDuration(cliCfg.Timeout)))
                c.SetRetryCount(cliCfg.RetryCount)
                c.SetRetryWaitTime(utils.Must(time.ParseDuration(cliCfg.RetryWaitTime)))
                c.SetRetryMaxWaitTime(utils.Must(time.ParseDuration(cliCfg.RetryMaxWaitTime)))
                for _, funcName := range cliCfg.RetryConditionFuncs {
                        c.AddRetryCondition(*(*resty.RetryConditionFunc)(inspect.FuncOf(funcName)))
                }
                for _, hookName := range cliCfg.RetryHooks {
                        c.AddRetryHook(*(*resty.OnRetryFunc)(inspect.FuncOf(hookName)))
                }

                dialer := &net.Dialer{
                        Timeout:   utils.Must(time.ParseDuration(cliCfg.DialTimeout)),
                        KeepAlive: utils.Must(time.ParseDuration(cliCfg.DialKeepaliveTime)),
                }

                c.SetTransport(&http.Transport{
                        Proxy:                 http.ProxyFromEnvironment,
                        DialContext:           dialer.DialContext,
                        ForceAttemptHTTP2:     cliCfg.ForceAttemptHTTP2,
                        DisableCompression:    cliCfg.DisableCompression,
                        IdleConnTimeout:       utils.Must(time.ParseDuration(cliCfg.IdleConnTimeout)),
                        TLSHandshakeTimeout:   utils.Must(time.ParseDuration(cliCfg.TLSHandshakeTimeout)),
                        ExpectContinueTimeout: utils.Must(time.ParseDuration(cliCfg.TLSHandshakeTimeout)),
                        MaxIdleConns:          cliCfg.MaxIdleConns,
                        MaxIdleConnsPerHost:   cliCfg.MaxIdleConnsPerHost,
                        MaxConnsPerHost:       cliCfg.MaxConnsPerHost,
                })

                if cliCfg.Mock {
                        httpmock.ActivateNonDefault(c.GetClient())
                }
        }

        if _, ok := appClientMap[opt.appName]; !ok {
                appClientMap[opt.appName] = make(map[string]*resty.Client)
        }
        appClientMap[opt.appName][opt.name] = c
        return applyClientOptions(c, opt)
}

func router.convert

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func (r *router) convert(method, uri string, handler routerHandler, opt *routerOption) gin.HandlerFunc {
        // check IRouter handler type
        typ := reflect.TypeOf(handler)
        if err := r.checkHandlerType(method, uri, typ); err != nil {
                panic(err)
        }

        // return raw gin handler
        if typ.NumIn() == 1 && typ.NumOut() == 0 {
                return func(c *gin.Context) {
                        reflect.ValueOf(handler).Call([]reflect.Value{reflect.ValueOf(c)})
                        c.Next()
                }
        }

        // parse request&response
        if typ.NumIn() == 1 {
                return r.wrapHandlerFunc(handler, nil)
        }

        parseMap := map[parseFrom]routerRequestParser{
                parseFromBody:  r.parseReqFromBody,
                parseFromQuery: r.parseReqFromQuery,
        }

        var reqParse routerRequestParser
        if p, ok := parseMap[opt.parseFrom]; ok {
                reqParse = p
        } else if methodWithBody[method] {
                reqParse = r.parseReqFromBody
        } else {
                reqParse = r.parseReqFromQuery
        }

        return r.wrapHandlerFunc(handler, reqParse)
}

func router.Start

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func (r *router) Start() {
        if _, ok := utils.IsChannelClosed(r.open); ok {
                return
        }
        conf := r.Config()
        gracefully.DefaultReadTimeOut = conf.ReadTimeout
        gracefully.DefaultWriteTimeOut = conf.WriteTimeout
        gracefully.DefaultMaxHeaderBytes = 1 << 20 // use http.DefaultMaxHeaderBytes - which currently is 1 << 20 (1MB)

        port := fmt.Sprintf(":%v", conf.Port)
        srv := gracefully.NewServer(r.appName, r.IRouter.(*gin.Engine), port, conf.NextProtos)
        r.shutdownFunc = srv.Shutdown
        if conf.TLS {
                routine.Go(srv.ListenAndServeTLS, routine.Args(conf.Cert, conf.Key), routine.AppName(r.appName))
        } else {
                routine.Go(srv.ListenAndServe, routine.AppName(r.appName))
        }

        r.close = make(chan struct{})
        close(r.open)
}

func lookupFieldByMap

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func lookupFieldByMap(v reflect.Value, keywords map[string]bool) (reflect.Value, bool) {
        vMap, ok := v.Interface().(map[string]any)
        if !ok {
                return reflect.Value{}, false
        }

        for key := range keywords {
                if vv, ok := vMap[key]; ok {
                        return reflect.ValueOf(vv), true
                }
        }
        return reflect.Value{}, false
}

func Use

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/construct.go:

func Use(opts ...utils.OptionExtender) IRouter {
        opt := utils.ApplyOptions[useOption](opts...)
        locker.RLock()
        defer locker.RUnlock()

        router, ok := routers[opt.appName]
        if !ok {
                panic(errors.Errorf("router not found"))
        }
        return router
}

func router.rspEmbed

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func (r *router) rspEmbed(c *gin.Context, rspVal reflect.Value, rspType reflect.Type, err error) {
        var data any
        if rspVal.IsValid() {
                data = rspVal.Interface()
        } else {
                data = reflect.New(rspType).Interface()
        }

        embedResponse(c, data, err)

        switch rsp := data.(type) {
        case Response:
                go metricsCode(r.ctx, r.appName, c.Request.URL.Path, c.Request.Method, rsp.Code,
                        c.Writer.Status(), c.Writer.Size(), c.Request.ContentLength)
        case *Response:
                go metricsCode(r.ctx, r.appName, c.Request.URL.Path, c.Request.Method, rsp.Code,
                        c.Writer.Status(), c.Writer.Size(), c.Request.ContentLength)
        default:
                rspData := make(map[string]any)
                dec, err := mapstructure.NewDecoder(&mapstructure.DecoderConfig{
                        Result:  &rspData,
                        TagName: "json",
                })
                if err == nil && dec != nil {
                        _ = dec.Decode(data)
                }
                var code any
                utils.IfAny(
                        func() (ok bool) { code, ok = rspData["code"]; return ok },
                        func() (ok bool) { code, ok = rspData["Code"]; return ok },
                )
                if code == nil {
                        code = -2
                }
                go metricsCode(r.ctx, r.appName, c.Request.URL.Path, c.Request.Method, cast.ToInt(code),
                        c.Writer.Status(), c.Writer.Size(), c.Request.ContentLength)
        }

}

func rspError

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/response.go:

func rspError[T constraint.Integer](c *gin.Context, appName string, code T, data any, page, count int, msg string) {
        status := c.Writer.Status()
        if status <= 0 {
                status = http.StatusBadRequest
        }

        if msg == "" {
                msg = Localizable(AppName(appName)).Localize(Errcode(code), i18n.Langs(langs(c)))
        }
        var (
                pagePtr  *int
                countPtr *int
        )
        if page > 0 {
                pagePtr = utils.AnyPtr(page)
        }
        if count >= 0 {
                countPtr = utils.AnyPtr(count)
        }

        c.PureJSON(status, &Response{
                Code:    cast.ToInt(code),
                Message: msg,
                Data:    data,
                Page:    pagePtr,
                Count:   countPtr,
                TraceID: c.GetString(fusCtx.KeyTraceID),
        })
}

func @132:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/construct.go:

func() {
                locker.Lock()
                defer locker.Unlock()
                if routers != nil {
                        if router, ok := routers[opt.AppName]; ok {
                                router.shutdown()
                                wg := new(sync.WaitGroup)
                                wg.Add(1)
                                go func() { defer wg.Done(); <-router.Closing() }()
                                if utils.Timeout(15*time.Second, utils.TimeoutWg(wg)) {
                                        pid := syscall.Getpid()
                                        app := config.Use(opt.AppName).AppName()
                                        log.Printf("%v [Gofusion] %s %s close http server timeout", pid, app, config.ComponentHttp)
                                }
                        }

                        delete(routers, opt.AppName)
                }
                if opt.AppName == "" {
                        Router = nil
                }
        }

func router.use

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func (r *router) use() gin.IRoutes {
        switch r.ptr {
        case dispatchIRouter:
                return r.IRouter
        case dispatchGroup:
                return r.group
        case dispatchRoutes:
                return r.routes
        default:
                return r.IRouter
        }
}

func router.parseReqFromBody

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func (r *router) parseReqFromBody(c *gin.Context, typ reflect.Type) (dst reflect.Value, err error) {
        ptrDepth := 0
        for typ.Kind() == reflect.Ptr {
                typ = typ.Elem()
                ptrDepth++
        }
        defer func() {
                for ptrDepth > 0 {
                        dst = dst.Addr()
                        ptrDepth--
                }
        }()

        bodyBytes, _ := io.ReadAll(c.Request.Body)
        c.Request.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))

        dst = reflect.Indirect(reflect.New(typ))
        if err = c.ShouldBind(dst.Addr().Interface()); err != nil &&
                !(errors.Is(err, binding.ErrConvertToMapString) || (errors.Is(err, binding.ErrConvertMapStringSlice))) {
                return
        }
        defer func() { c.Request.Body = io.NopCloser(bytes.NewBuffer(bodyBytes)) }()

        if dst.IsZero() {
                var (
                        p           parser.Parser
                        param       map[string]string
                        contentType string
                )
                if contentType, param, err = mime.ParseMediaType(c.GetHeader("Content-Type")); err != nil {
                        return
                }
                if p, err = parser.GetByContentType(contentType); err != nil {
                        return
                }
                if err = p.PreParse(param); err != nil {
                        return
                }
                c.Request.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))
                if err = p.Parse(c.Request.Body, dst); err != nil {
                        return
                }
        }

        err = utils.ParseTag(
                dst.Addr().Interface(),
                utils.ParseTagName("default"),
                utils.ParseTagUnmarshalType(utils.UnmarshalTypeYaml),
        )

        return
}

func @539:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func(c *gin.Context) {
                var (
                        err     error
                        reqVal  reflect.Value
                        rspVals []reflect.Value
                )

                // deal with request & call handler
                if reqParse == nil {
                        rspVals = reflect.ValueOf(handler).Call([]reflect.Value{reflect.ValueOf(c)})
                } else if reqVal, err = reqParse(c, typ.In(1)); err == nil {
                        rspVals = reflect.ValueOf(handler).Call([]reflect.Value{reflect.ValueOf(c), reqVal})
                } else {
                        switch e := err.(type) {
                        case *json.UnmarshalTypeError:
                                msg := fmt.Sprintf(": %s field type should be %s", e.Value, e.Type.String())
                                r.rspError(c, nil, Err(c, errParam, Param(map[string]any{"err": msg})))
                        default:
                                r.rspError(c, nil, Err(c, errParam,
                                        Param(map[string]any{"err": fmt.Sprintf(": %s", err.Error())})))
                        }
                        c.Next()
                        return
                }

                // deal with response
                errVal := rspVals[numOut-1]
                if !errVal.IsNil() {
                        err = errVal.Interface().(error)
                }
                rspVals = rspVals[:numOut-1]

                var rspType reflect.Type
                isEmbed, isResponse := false, false
                if len(rspVals) > 0 {
                        rspType = utils.IndirectType(rspVals[0].Type())
                        isEmbed = utils.EmbedsType(rspType, embedType)
                        isResponse = utils.EmbedsType(rspType, responseType)
                }

                switch {
                case isEmbed, isResponse:
                        r.rspEmbed(c, rspVals[0], rspType, err) // directly json marshal embed response
                case err != nil:
                        r.rspError(c, rspVals, err) // business error
                default:
                        r.rspSuccess(c, rspVals) // success with response
                }

                c.Next()
        }

func initAsynq

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/asynq.go:

func initAsynq(ctx context.Context, appName string, r IRouter, confs []asynqConf) {
        if len(confs) == 0 || r == nil {
                return
        }

        for _, conf := range confs {
                switch conf.InstanceType {
                case instanceTypeRedis:
                default:
                        panic(errors.Errorf("unknown asynq instance type: %+v", conf.InstanceType))
                }
                connOpt := &asynqRedisConnOpt{UniversalClient: redis.Use(ctx, conf.Instance, redis.AppName(appName))}
                h := asynqmon.New(asynqmon.Options{
                        RootPath:          conf.Path,
                        RedisConnOpt:      connOpt,
                        PayloadFormatter:  nil,
                        ResultFormatter:   nil,
                        PrometheusAddress: conf.PrometheusAddress,
                        ReadOnly:          conf.Readonly,
                })

                r.Any(h.RootPath()+"/*any", gin.WrapH(h))
        }
}

func lookupFieldByValue

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func lookupFieldByValue(v reflect.Value, keywords map[string]bool) (reflect.Value, bool) {
        f := reflect.Indirect(v.FieldByNameFunc(func(s string) bool { return keywords[s] }))
        if !f.IsValid() || f.IsZero() {
                return reflect.Value{}, false
        }
        return reflect.Indirect(f), true
}

func router.convertMulti

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func (r *router) convertMulti(method, uri string, hdr routerHandler, opt *routerOption) (result gin.HandlersChain) {
        result = make(gin.HandlersChain, 0, len(opt.beforeHandlers)+len(opt.aftersHandlers)+1)
        for _, hdr := range opt.beforeHandlers {
                result = append(result, r.convert(method, uri, hdr, opt))
        }
        result = append(result, r.convert(method, uri, hdr, opt))
        for _, hdr := range opt.aftersHandlers {
                result = append(result, r.convert(method, uri, hdr, opt))
        }
        return
}

func metricsCode

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/metrics.go:

func metricsCode(ctx context.Context, appName, path, method string, code, status, rspSize int, reqSize int64) {
        select {
        case <-ctx.Done():
                return
        default:

        }

        // skip health check logging
        if path == "/health" && method == http.MethodGet {
                return
        }

        app := config.Use(appName).AppName()
        labels := []metrics.Label{
                {Key: "path", Value: path},
                {Key: "method", Value: method},
                {Key: "code", Value: cast.ToString(code)},
                {Key: "status", Value: cast.ToString(status)},
                {Key: "req_size", Value: cast.ToString(reqSize)},
                {Key: "rsp_size", Value: cast.ToString(rspSize)},
        }
        totalKey := append([]string{app}, metricsCodeTotalKey...)
        for _, m := range metrics.Internal(metrics.AppName(appName)) {
                select {
                case <-ctx.Done():
                        return
                default:
                        if m.IsEnableServiceLabel() {
                                m.IncrCounter(ctx, totalKey, 1, metrics.Labels(labels))
                        } else {
                                m.IncrCounter(ctx, metricsCodeTotalKey, 1, metrics.Labels(labels))
                        }
                }
        }
}

func traceHeaderMiddleware

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/client.go:

func traceHeaderMiddleware(cli *resty.Client, req *resty.Request) (err error) {
        ctx := req.Context()
        if userID := fusCtx.GetUserID(ctx); utils.IsStrNotBlank(userID) {
                req.SetHeader("User-ID", userID)
        }
        if traceID := fusCtx.GetTraceID(ctx); utils.IsStrNotBlank(traceID) {
                req.SetHeader("Trace-ID", traceID)
        }
        return
}

func router.checkHandlerType

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func (r *router) checkHandlerType(method, uri string, typ reflect.Type) (err error) {
        if typ.Kind() != reflect.Func {
                return errors.Errorf("router handler should be a function [method[%s] uri[%s]]", method, uri)
        }

        // check in
        if typ.NumIn() < 1 {
                return errors.Errorf("router handler should have at least 1 parameter in "+
                        "[method[%s] uri[%s]]", method, uri)
        }
        if typ.NumIn() > 2 {
                return errors.Errorf("router handler should not have more than 2 parameters in "+
                        "[method[%s] uri[%s]]", method, uri)
        }
        if typ.In(0) != constant.GinContextType {
                return errors.Errorf("router handler first parameter in should be *gin.Context "+
                        "[method[%s] uri[%s]]", method, uri)
        }
        if typ.NumIn() == 2 {
                if !r.checkParamType(typ.In(1), supportParamType) {
                        return errors.Errorf("router handler second parameter in type not supportted "+
                                "[method[%s] uri[%s]]", method, uri)
                }
        }

        // check out

        // check error
        if typ.NumOut() > 0 && !typ.Out(typ.NumOut()-1).AssignableTo(constant.ErrorType) {
                return errors.Errorf("router handler last paramater out should be error type "+
                        "[method[%s] uri[%s]]", method, uri)
        }

        // check (data any, page, count int, msg string, err error)
        if numOut := typ.NumOut(); numOut > 1 {
                supportTypes := supportReturnTypeList[numOut-1]
                for i := 0; i < numOut-1; i++ {
                        if !r.checkParamType(typ.Out(i), supportTypes[i]) {
                                return errors.Errorf("router handler paramater out format is illegal "+
                                        "[method[%s] uri[%s] index[%v] unsupported[%s] suppoted[%+v]]",
                                        method, uri, i+1, typ.Out(i).Kind(), supportTypes[i])
                        }
                }
        }

        return
}

func ginZeroCopyWriter.ReadFrom

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/zerocopy.go:

func (z *ginZeroCopyWriter) ReadFrom(r io.Reader) (n int64, err error) {
        var size int64
        if limitedReader, ok := r.(*io.LimitedReader); ok {
                size = limitedReader.N
        }

        // forces to write the http header (status code + headers)
        z.ResponseWriter.WriteHeaderNow()
        if z.ctx.Request.Method == http.MethodHead {
                return size, nil
        }

        // hijack conn to call zero copy
        var conn net.Conn
        _, err = utils.Catch(func() (err error) { conn, _, err = z.ResponseWriter.Hijack(); return })
        if err != nil || conn == nil {
                // write by memory buffer
                if size > 0 {
                        return io.CopyN(z.ResponseWriter, r.(*io.LimitedReader), size)
                }
                return io.Copy(z.ResponseWriter, r)
        }
        defer func() {
                if closeErr := conn.Close(); closeErr != nil {
                        err = multierr.Append(err, closeErr)
                }
        }()

        // set write timeout again because it is reset when hijack
        if err = conn.SetWriteDeadline(time.Now().Add(gracefully.DefaultWriteTimeOut)); err != nil {
                return
        }

        // write body
        return io.Copy(conn, r)
}

func parseRspError

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func parseRspError(rspVals []reflect.Value, err error) (code int, data any, page, count int, msg string) {
        switch e := err.(type) {
        case Errcode:
                code, msg = int(e), e.Error()
        case *bizErr:
                code, msg = int(e.code), e.Error()
        default:
                code, msg = http.StatusBadRequest, e.Error()
        }

        data, page, count, retMsg := parseRspSuccess(rspVals)
        if retMsg != "" {
                msg = retMsg
        }

        return
}

func parseRspSuccess

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func parseRspSuccess(rspVals []reflect.Value) (data any, page, count int, msg string) {
        switch {
        case len(rspVals) == 0:
        case len(rspVals) == 2:
                data = transformData(rspVals[0])
                msg = reflect.Indirect(rspVals[1]).String()
        case len(rspVals) == 3:
                data = transformData(rspVals[0])
                count = cast.ToInt(reflect.Indirect(rspVals[1]).Int())
                msg = reflect.Indirect(rspVals[2]).String()
        case len(rspVals) > 3:
                data = transformData(rspVals[0])
                page = cast.ToInt(reflect.Indirect(rspVals[1]).Int())
                count = cast.ToInt(reflect.Indirect(rspVals[2]).Int())
                msg = reflect.Indirect(rspVals[3]).String()
        default:
                data, page, count, msg = lookupFieldByStruct(rspVals[0])
        }

        return
}

func transformData

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func transformData(data reflect.Value) (transformed any) {
        if !data.IsValid() {
                return
        }

        // some structs return as an interface
        if data.Kind() == reflect.Interface {
                data = reflect.ValueOf(data.Interface())
        }
        if data = utils.IndirectValue(data); !data.IsValid() {
                return
        }

        return data.Interface()
}

func @30:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/zerocopy.go:

func(c *gin.Context) {
                name, modTime, content, err := fn(c)
                if err != nil {
                        code, data, page, count, msg := parseRspError(nil, err)
                        rspError(c, opt.appName, code, data, page, count, msg)
                        c.Abort()
                        return
                }
                defer utils.CloseAnyway(content)
                http.ServeContent(&ginZeroCopyWriter{ResponseWriter: c.Writer, ctx: c}, c.Request, name, modTime, content)
        }

func embedResponse

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/response.go:

func embedResponse(c *gin.Context, data any, err error) {
        status := c.Writer.Status()
        if status == 0 {
                if err != nil {
                        status = http.StatusOK
                } else {
                        status = http.StatusBadRequest
                }
        }

        c.PureJSON(status, data)
}

func router.useIRouter

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func (r *router) useIRouter() gin.IRouter {
        switch r.ptr {
        case dispatchIRouter:
                return r.IRouter
        case dispatchGroup:
                return r.group
        case dispatchRoutes:
                panic(errors.New("group method unsupported for gin.Routes interface"))
        default:
                return r.IRouter
        }
}

func applyClientOptions

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/client.go:

func applyClientOptions(src *resty.Client, opt *clientOption) (dst *resty.Client) {
RetryConditionLoop:
        for _, cond := range opt.retryConditions {
                condName := utils.GetFuncName(cond)
                for _, exist := range src.RetryConditions {
                        if condName == utils.GetFuncName(exist) {
                                break RetryConditionLoop
                        }
                }
                src.AddRetryCondition(cond)
        }

RetryHookLoop:
        for _, hook := range opt.retryHooks {
                condName := utils.GetFuncName(hook)
                for _, exist := range src.RetryHooks {
                        if condName == utils.GetFuncName(exist) {
                                break RetryHookLoop
                        }
                }
                src.AddRetryHook(hook)
        }

        return src
}

func router.ListenAndServe

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func (r *router) ListenAndServe() (err error) {
        if _, ok := utils.IsChannelClosed(r.open); ok {
                <-r.Closing()
                return
        }

        conf := r.Config()
        gracefully.DefaultReadTimeOut = conf.ReadTimeout
        gracefully.DefaultWriteTimeOut = conf.WriteTimeout
        gracefully.DefaultMaxHeaderBytes = 1 << 20 // use http.DefaultMaxHeaderBytes - which currently is 1 << 20 (1MB)

        port := fmt.Sprintf(":%v", conf.Port)
        srv := gracefully.NewServer(r.appName, r.IRouter.(*gin.Engine), port, conf.NextProtos)
        r.shutdownFunc = srv.Shutdown

        r.close = make(chan struct{})
        close(r.open)
        defer func() {
                close(r.close)
                r.open = make(chan struct{})
        }()

        if conf.TLS {
                return srv.ListenAndServeTLS(conf.Cert, conf.Key)
        } else {
                return srv.ListenAndServe()
        }
}

func langs

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/response.go:

func langs(c *gin.Context) (langs []string) {
        if c == nil {
                return
        }
        langs = c.Request.Header.Values("Accept-Language")
        if lang := c.GetString("lang"); utils.IsStrNotBlank(lang) {
                langs = append(langs, lang)
        }
        if lang := c.GetString(fusCtx.KeyLangs); utils.IsStrNotBlank(lang) {
                langs = append(langs, lang)
        }
        return langs
}

func Localizable

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/i18n.go:

func Localizable(opts ...utils.OptionExtender) i18n.Localizable[Errcode] {
        opt := utils.ApplyOptions[useOption](opts...)

        locker.RLock()
        defer locker.RUnlock()
        i, ok := i18ns[opt.appName]
        if !ok {
                panic(errors.Errorf("http i18n not founc: %s", opt.appName))
        }
        return i
}

func @101:17

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/construct.go:

func(c *gin.Context) {
                c.Status(http.StatusNotFound)
                msg := fmt.Sprintf("找不到该内容, URL: %s", c.Request.URL.String())
                if tag != language.Chinese {
                        msg = fmt.Sprintf("Cannot find URL content: %s", c.Request.URL.String())
                }
                rspError(c, opt.AppName, -1, nil, 0, 0, msg)
        }

func @92:18

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/construct.go:

func(c *gin.Context) {
                c.Status(http.StatusMethodNotAllowed)
                msg := fmt.Sprintf("找不到该方法, Method: %s", c.Request.Method)
                if tag != language.Chinese {
                        msg = fmt.Sprintf("Cannot find method: %s", c.Request.Method)
                }

                rspError(c, opt.AppName, -1, nil, 0, 0, msg)
        }

func ErrCtx

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/error.go:

func ErrCtx(ctx context.Context, code Errcode, opts ...utils.OptionExtender) error {
        opt := utils.ApplyOptions[errOption](opts...)
        if len(opt.langs) == 0 {
                opt.langs = fusCtx.GetLangs(ctx)
        }
        return &bizErr{
                code:      code,
                errOption: opt,
        }
}

func Err

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/error.go:

func Err(c *gin.Context, code Errcode, opts ...utils.OptionExtender) error {
        opt := utils.ApplyOptions[errOption](opts...)
        if len(opt.langs) == 0 {
                opt.langs = langs(c)
        }
        return &bizErr{
                code:      code,
                errOption: opt,
        }
}

func router.Handle

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func (r *router) Handle(uri string, fn routerHandler, opts ...utils.OptionExtender) IRouter {
        opt := utils.ApplyOptions[routerOption](opts...)
        r.use().HEAD(uri, r.convertMulti("Handle", uri, fn, opt)...)
        return r
}

func bizErr.Error

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/error.go:

func (b *bizErr) Error() (r string) {
        if b.msg != "" {
                return b.msg
        }
        return I18n.Localize(b.code, i18n.Langs(b.langs), i18n.Param(b.param))
}

func router.HEAD

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func (r *router) HEAD(uri string, fn routerHandler, opts ...utils.OptionExtender) IRouter {
        opt := utils.ApplyOptions[routerOption](opts...)
        r.use().HEAD(uri, r.convertMulti(http.MethodHead, uri, fn, opt)...)
        return r
}

func router.PATCH

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func (r *router) PATCH(uri string, fn routerHandler, opts ...utils.OptionExtender) IRouter {
        opt := utils.ApplyOptions[routerOption](opts...)
        r.use().PATCH(uri, r.convertMulti(http.MethodPatch, uri, fn, opt)...)
        return r
}

func router.DELETE

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func (r *router) DELETE(uri string, fn routerHandler, opts ...utils.OptionExtender) IRouter {
        opt := utils.ApplyOptions[routerOption](opts...)
        r.use().DELETE(uri, r.convertMulti(http.MethodDelete, uri, fn, opt)...)
        return r
}

func @43:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/client.go:

func(o *clientOption) {
                o.mu.Lock()
                defer o.mu.Unlock()
                o.retryConditions = append(o.retryConditions, fn)
        }

func @51:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/client.go:

func(o *clientOption) {
                o.mu.Lock()
                defer o.mu.Unlock()
                o.retryHooks = append(o.retryHooks, fn)
        }

func router.PUT

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func (r *router) PUT(uri string, fn routerHandler, opts ...utils.OptionExtender) IRouter {
        opt := utils.ApplyOptions[routerOption](opts...)
        r.use().PUT(uri, r.convertMulti(http.MethodPut, uri, fn, opt)...)
        return r
}

func router.OPTIONS

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func (r *router) OPTIONS(uri string, fn routerHandler, opts ...utils.OptionExtender) IRouter {
        opt := utils.ApplyOptions[routerOption](opts...)
        r.use().OPTIONS(uri, r.convertMulti(http.MethodOptions, uri, fn, opt)...)
        return r
}

func router.StaticFileFS

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

155	`func (r *router) StaticFileFS(uri, file string, fs http.FileSystem) IRouter {`
156	`r.use().StaticFileFS(uri, file, fs)`
157	`return r`
158	`}`

func router.Static

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

159	`func (r *router) Static(uri, file string) IRouter { r.use().Static(uri, file); return r }`

func router.StaticFS

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

160	`func (r *router) StaticFS(uri string, fs http.FileSystem) IRouter {`
161	`r.use().StaticFS(uri, fs)`
162	`return r`
163	`}`

func @185:8

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

185	`func() {`
186	`close(r.close)`
187	`r.open = make(chan struct{})`
188	`}`

func @71:8

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/zerocopy.go:

func() {
                if closeErr := conn.Close(); closeErr != nil {
                        err = multierr.Append(err, closeErr)
                }
        }

func Langs

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/error.go:

func Langs(c *gin.Context) utils.OptionFunc[errOption] {
        return func(e *errOption) {
                e.langs = langs(c)
        }
}

func @129:22

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/construct.go:

129	`func() IRouter { return Use(AppName(opt.AppName)) }`

func @219:23

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/construct.go:

219	`func() *resty.Client { return New(AppName(opt.AppName), CName(name)) }`

func Errcode.Error

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/error.go:

26	`func (e Errcode) Error() (r string) {`
27	`return I18n.Localize(e)`
28	`}`

func @37:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/error.go:

37	`func(e *errOption) {`
38	`e.langs = langs(c)`
39	`}`

func @797:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

797	`func(r *routerOption) {`
798	`r.parseFrom = parseFromBody`
799	`}`

func ParseFromQuery

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func ParseFromQuery() utils.OptionFunc[routerOption] {
        return func(r *routerOption) {
                r.parseFrom = parseFromQuery
        }
}

func @803:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

803	`func(r *routerOption) {`
804	`r.parseFrom = parseFromQuery`
805	`}`

func HandleBefore

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func HandleBefore(beforeHandlers ...routerHandler) utils.OptionFunc[routerOption] {
        return func(o *routerOption) {
                o.beforeHandlers = beforeHandlers
        }
}

func @809:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

809	`func(o *routerOption) {`
810	`o.beforeHandlers = beforeHandlers`
811	`}`

func HandleAfter

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func HandleAfter(aftersHandlers ...routerHandler) utils.OptionFunc[routerOption] {
        return func(o *routerOption) {
                o.aftersHandlers = aftersHandlers
        }
}

func @815:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

815	`func(o *routerOption) {`
816	`o.aftersHandlers = aftersHandlers`
817	`}`

func Param

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/error.go:

func Param(param map[string]any) utils.OptionFunc[errOption] {
        return func(e *errOption) {
                e.param = param
        }
}

func RetryHook

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/client.go:

func RetryHook(fn resty.OnRetryFunc) utils.OptionFunc[clientOption] {
        return func(o *clientOption) {
                o.mu.Lock()
                defer o.mu.Unlock()
                o.retryHooks = append(o.retryHooks, fn)
        }
}

func @43:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/error.go:

43	`func(e *errOption) {`
44	`e.param = param`
45	`}`

func ParseFromBody

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/router.go:

func ParseFromBody() utils.OptionFunc[routerOption] {
        return func(r *routerOption) {
                r.parseFrom = parseFromBody
        }
}

func Msg

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/error.go:

func Msg(msg string) utils.OptionFunc[errOption] {
        return func(e *errOption) {
                e.msg = msg
        }
}

func RetryCondition

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/client.go:

func RetryCondition(fn resty.RetryConditionFunc) utils.OptionFunc[clientOption] {
        return func(o *clientOption) {
                o.mu.Lock()
                defer o.mu.Unlock()
                o.retryConditions = append(o.retryConditions, fn)
        }
}

func @49:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/error.go:

49	`func(e *errOption) {`
50	`e.msg = msg`
51	`}`

Package Overview: github.com/wfusion/gofusion/http/consts 88.9%

Please select a function to see what's left for testing.

`SetReqStartTime(...)`	`github.com/wfusion/gofusion/http/consts/context.go`	`100.0%`	`1/1`
`GetReqCost(...)`	`github.com/wfusion/gofusion/http/consts/context.go`	`87.5%`	`7/8`

func SetReqStartTime

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/consts/context.go:

15	`func SetReqStartTime(c *gin.Context) {`
16	`c.Set(ctxReqStartAtKey, time.Now())`
17	`}`

func GetReqCost

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/consts/context.go:

func GetReqCost(c *gin.Context) time.Duration {
        if cost, ok := c.Get(ctxReqCostKey); ok {
                return cast.ToDuration(cost)
        }

        start := time.Now()
        if _, ok := c.Get(ctxReqStartAtKey); ok {
                start = c.GetTime(ctxReqStartAtKey)
        }
        cost := time.Since(start)
        c.Set(ctxReqCostKey, cost)
        return cost
}

Package Overview: github.com/wfusion/gofusion/http/gracefully 37.8%

Please select a function to see what's left for testing.

`endlessServer.Serve(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`100.0%`	`11/11`
`endlessListener.Accept(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`100.0%`	`8/8`
`init(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`100.0%`	`6/6`
`endlessServer.setState(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`100.0%`	`3/3`
`endlessServer.getState(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`100.0%`	`3/3`
`endlessConn.Close(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`100.0%`	`2/2`
`endlessConn.SetReadDeadline(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`100.0%`	`1/1`
`endlessConn.RemoteAddr(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`100.0%`	`1/1`
`endlessConn.SetWriteDeadline(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`100.0%`	`1/1`
`@505:22(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`100.0%`	`1/1`
`endlessConn.Write(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`100.0%`	`1/1`
`init(...)`	`github.com/wfusion/gofusion/http/gracefully/signal_darwin.go`	`100.0%`	`1/1`
`newSignalHookFunc(...)`	`github.com/wfusion/gofusion/http/gracefully/signal_darwin.go`	`100.0%`	`1/1`
`newEndlessListener(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`100.0%`	`1/1`
`endlessConn.LocalAddr(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`100.0%`	`1/1`
`endlessConn.Read(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`100.0%`	`1/1`
`NewServer(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`83.3%`	`10/12`
`endlessServer.Shutdown(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`80.0%`	`8/10`
`endlessListener.Close(...)`	`github.com/wfusion/gofusion/http/gracefully/signal_darwin.go`	`75.0%`	`3/4`
`endlessServer.ListenAndServe(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`62.5%`	`10/16`
`@356:8(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`50.0%`	`1/2`
`endlessServer.hammerTime(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`30.0%`	`3/10`
`endlessServer.getListener(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`23.5%`	`4/17`
`endlessServer.handleSignals(...)`	`github.com/wfusion/gofusion/http/gracefully/signal_darwin.go`	`15.8%`	`6/38`
`endlessServer.fork(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`0.0%`	`0/27`
`endlessServer.ListenAndServeTLS(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`0.0%`	`0/26`
`endlessServer.RegisterSignalHook(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`0.0%`	`0/9`
`endlessServer.signalHooks(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`0.0%`	`0/4`
`endlessListener.File(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`0.0%`	`0/3`
`ListenAndServe(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`0.0%`	`0/2`
`ListenAndServeTLS(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`0.0%`	`0/2`
`endlessConn.SetKeepAlive(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`0.0%`	`0/1`
`endlessConn.SetKeepAlivePeriod(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`0.0%`	`0/1`
`endlessConn.SetNoDelay(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`0.0%`	`0/1`
`endlessConn.SetLinger(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`0.0%`	`0/1`
`endlessConn.ReadFrom(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`0.0%`	`0/1`
`endlessConn.SyscallConn(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`0.0%`	`0/1`
`endlessConn.SetDeadline(...)`	`github.com/wfusion/gofusion/http/gracefully/endless.go`	`0.0%`	`0/1`
`syscallKill(...)`	`github.com/wfusion/gofusion/http/gracefully/signal_darwin.go`	`0.0%`	`0/1`

func endlessServer.Serve

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

func (e *endlessServer) Serve() (err error) {
        defer log.Println(syscall.Getpid(), "[Common] endless exited.")

        e.setState(StateRunning)
        log.Println(syscall.Getpid(), "[Common] endless listening", e.endlessListener.Addr())

        // ignore server closed error because it happened when we call Server.Shutdown or Server.Close
        if err = e.Server.Serve(e.endlessListener); err != nil {
                // http: Server closed
                // use of closed network connection
                if errors.Is(err, http.ErrServerClosed) || isClosedConnError(err) {
                        err = nil
                }
        }
        log.Println(syscall.Getpid(), "[Common] endless waiting for connections to finish...")
        e.wg.Wait()
        e.setState(StateTerminate)

        <-e.close

        return
}

func endlessListener.Accept

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

func (e *endlessListener) Accept() (c net.Conn, err error) {
        tc, err := e.Listener.(*net.TCPListener).AcceptTCP()
        if err != nil {
                return
        }

        // see net/http.tcpKeepAliveListener
        _ = tc.SetKeepAlive(true)
        // see net/http.tcpKeepAliveListener
        _ = tc.SetKeepAlivePeriod(3 * time.Minute)

        c = &endlessConn{
                Conn:   tc,
                server: e.server,
        }

        e.server.wg.Add(1)
        return
}

func init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

func init() {
        runningServerReg = sync.RWMutex{}
        runningServers = make(map[string]*endlessServer)
        runningServersOrder = []string{}
        socketPtrOffsetMap = make(map[string]uint)

        DefaultMaxHeaderBytes = 0 // use http.DefaultMaxHeaderBytes - which currently is 1 << 20 (1MB)

        // after a restart the parent will finish ongoing requests before
        // shutting down. set to a negative value to disable
        DefaultHammerTime = 60 * time.Second
}

func endlessServer.setState

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

func (e *endlessServer) setState(st uint8) {
        e.lock.Lock()
        defer e.lock.Unlock()

        e.state = st
}

func endlessServer.getState

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

func (e *endlessServer) getState() uint8 {
        e.lock.RLock()
        defer e.lock.RUnlock()

        return e.state
}

func endlessConn.Close

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

func (e *endlessConn) Close() (err error) {
        defer e.doneOnce.Do(func() {
                e.server.wg.Done()
        })
        return e.Conn.Close()
}

func endlessConn.SetReadDeadline

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

543	`func (e *endlessConn) SetReadDeadline(t time.Time) error { return e.Conn.SetReadDeadline(t) }`

func endlessConn.RemoteAddr

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

515	`func (e *endlessConn) RemoteAddr() net.Addr { return e.Conn.RemoteAddr() }`

func endlessConn.SetWriteDeadline

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

550	`func (e *endlessConn) SetWriteDeadline(t time.Time) error { return e.Conn.SetWriteDeadline(t) }`

func @505:22

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

505	`func() {`
506	`e.server.wg.Done()`
507	`}`

func endlessConn.Write

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

500	`func (e *endlessConn) Write(b []byte) (n int, err error) { return e.Conn.Write(b) }`

func init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/signal_darwin.go:

func init() {
        hookableSignals = []os.Signal{
                syscall.SIGHUP,
                syscall.SIGUSR1,
                syscall.SIGUSR2,
                syscall.SIGINT,
                syscall.SIGQUIT,
                syscall.SIGTERM,
                syscall.SIGTSTP,
        }
}

func newSignalHookFunc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/signal_darwin.go:

func newSignalHookFunc() map[int]map[os.Signal][]func() {
        return map[int]map[os.Signal][]func(){
                PreSignal: {
                        syscall.SIGHUP:  []func(){},
                        syscall.SIGUSR1: []func(){},
                        syscall.SIGUSR2: []func(){},
                        syscall.SIGINT:  []func(){},
                        syscall.SIGQUIT: []func(){},
                        syscall.SIGTERM: []func(){},
                        syscall.SIGTSTP: []func(){},
                },
                PostSignal: {
                        syscall.SIGHUP:  []func(){},
                        syscall.SIGUSR1: []func(){},
                        syscall.SIGUSR2: []func(){},
                        syscall.SIGINT:  []func(){},
                        syscall.SIGQUIT: []func(){},
                        syscall.SIGTERM: []func(){},
                        syscall.SIGTSTP: []func(){},
                },
        }
}

func newEndlessListener

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

func newEndlessListener(l net.Listener, srv *endlessServer) (el *endlessListener) {
        return &endlessListener{
                Listener: l,
                server:   srv,
        }
}

func endlessConn.LocalAddr

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

512	`func (e *endlessConn) LocalAddr() net.Addr { return e.Conn.LocalAddr() }`

func endlessConn.Read

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

495	`func (e *endlessConn) Read(b []byte) (n int, err error) { return e.Conn.Read(b) }`

func NewServer

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

func NewServer(appName string, handler http.Handler, addr string, nextProtos []string) (srv *endlessServer) {
        runningServerReg.Lock()
        defer runningServerReg.Unlock()

        socketOrder = os.Getenv("ENDLESS_SOCKET_ORDER")
        isChild = os.Getenv("ENDLESS_CONTINUE") != ""

        if len(socketOrder) > 0 {
                for i, addr := range strings.Split(socketOrder, ",") {
                        socketPtrOffsetMap[addr] = uint(i)
                }
        } else {
                socketPtrOffsetMap[addr] = uint(len(runningServersOrder))
        }

        srv = &endlessServer{
                AppName: appName,
                Server: &http.Server{
                        Addr:           addr,
                        ReadTimeout:    DefaultReadTimeOut,
                        WriteTimeout:   DefaultWriteTimeOut,
                        MaxHeaderBytes: DefaultMaxHeaderBytes,
                        Handler:        handler,
                        TLSConfig:      &tls.Config{NextProtos: nextProtos},
                },
                close:       make(chan struct{}),
                wg:          new(sync.WaitGroup),
                sigChan:     make(chan os.Signal),
                isChild:     isChild,
                SignalHooks: newSignalHookFunc(),
                state:       StateInit,
                lock:        new(sync.RWMutex),
        }

        runningServersOrder = append(runningServersOrder, addr)
        runningServers[addr] = srv

        return
}

func endlessServer.Shutdown

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

func (e *endlessServer) Shutdown() {
        // make sure server Shutdown & log printed before Serve() return
        defer close(e.close)

        if e.getState() != StateRunning {
                return
        }

        e.setState(StateShuttingDown)
        if DefaultHammerTime >= 0 {
                routine.Loop(e.hammerTime, routine.Args(DefaultHammerTime), routine.AppName(e.AppName))
        }
        // disable keep-alive on existing connections
        e.Server.SetKeepAlivesEnabled(false)

        // TODO: new context with timeout because system may forcefully kill the program
        if err := e.Server.Shutdown(context.TODO()); err != nil {
                log.Println(syscall.Getpid(), "[Common] endless close listener error:", err)
        } else {
                log.Println(syscall.Getpid(), "[Common] endless", e.endlessListener.Addr(), "listener closed.")
        }
}

func endlessListener.Close

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/signal_darwin.go:

func (e *endlessListener) Close() error {
        if e.stopped {
                return syscall.EINVAL
        }

        e.stopped = true
        return e.Listener.Close()
}

func endlessServer.ListenAndServe

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

func (e *endlessServer) ListenAndServe() (err error) {
        addr := e.Addr
        if addr == "" {
                addr = ":http"
        }

        if err = setupHTTP2_Serve(e.Server); err != nil {
                return
        }

        routine.Go(e.handleSignals, routine.AppName(e.AppName))

        l, err := e.getListener(addr)
        if err != nil {
                log.Println(syscall.Getpid(), "[Common] endless", err)
                return
        }

        e.endlessListener = newEndlessListener(l, e)
        if e.isChild {
                _ = syscallKill(syscall.Getppid())
        }

        if e.BeforeBegin != nil {
                e.BeforeBegin(e.Addr)
        }

        return e.Serve()
}

func @356:8

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

func() {
                // we are calling e.wg.Done() until it panics which means we called
                // Done() when the counter was already at 0, and we're done.
                // (and thus Serve() will return and the parent will exit)
                if r := recover(); r != nil {
                        log.Println(syscall.Getpid(), "[Common] endless wait group at 0", r)
                }
        }

func endlessServer.hammerTime

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

func (e *endlessServer) hammerTime(d time.Duration) {
        defer func() {
                // we are calling e.wg.Done() until it panics which means we called
                // Done() when the counter was already at 0, and we're done.
                // (and thus Serve() will return and the parent will exit)
                if r := recover(); r != nil {
                        log.Println(syscall.Getpid(), "[Common] endless wait group at 0", r)
                }
        }()
        if e.getState() != StateShuttingDown {
                return
        }
        time.Sleep(d)
        log.Println(syscall.Getpid(), "[Common] endless harmerTime() forcefully shutting down parent")
        for {
                if e.getState() == StateTerminate {
                        break
                }
                e.wg.Done()
                runtime.Gosched()
        }
}

func endlessServer.getListener

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

func (e *endlessServer) getListener(addr string) (l net.Listener, err error) {
        if e.isChild {
                ptrOffset := uint(0)
                runningServerReg.RLock()
                defer runningServerReg.RUnlock()
                if len(socketPtrOffsetMap) > 0 {
                        ptrOffset = socketPtrOffsetMap[addr]
                        log.Println(syscall.Getpid(), "[Common] endless addr:", addr, "ptr offset:", socketPtrOffsetMap[addr])
                }

                f := os.NewFile(uintptr(3+ptrOffset), "")
                l, err = net.FileListener(f)
                if err != nil {
                        err = fmt.Errorf("net.FileListener error: %v", err)
                        return
                }
        } else {
                l, err = net.Listen("tcp", addr)
                if err != nil {
                        err = fmt.Errorf("net.Listen error: %v", err)
                        return
                }
        }
        return
}

func endlessServer.handleSignals

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/signal_darwin.go:

func (e *endlessServer) handleSignals() {
        var sig os.Signal

        signal.Notify(
                e.sigChan,
                hookableSignals...,
        )

        pid := syscall.Getpid()
        for {
                select {
                case sig = <-e.sigChan:
                case <-e.close:
                        return
                }

                e.signalHooks(PreSignal, sig)
                switch sig {
                case syscall.SIGHUP:
                        signal.Stop(e.sigChan)
                        close(e.sigChan)
                        log.Println(pid, "[Common] endless received SIGHUP. forking...")
                        if err := e.fork(); err != nil {
                                log.Println("[Common] endless fork err:", err)
                        }
                        return
                case syscall.SIGUSR1:
                        log.Println(pid, "[Common] endless received SIGUSR1.")
                case syscall.SIGUSR2:
                        signal.Stop(e.sigChan)
                        close(e.sigChan)
                        log.Println(pid, "[Common] endless received SIGUSR2.")
                        e.hammerTime(0 * time.Second)
                        return
                case syscall.SIGINT:
                        signal.Stop(e.sigChan)
                        close(e.sigChan)
                        log.Println(pid, "[Common] endless received SIGINT.")
                        e.Shutdown()
                        return
                case syscall.SIGQUIT:
                        signal.Stop(e.sigChan)
                        close(e.sigChan)
                        log.Println(pid, "[Common] endless received SIGQUIT.")
                        e.Shutdown()
                        return
                case syscall.SIGTERM:
                        signal.Stop(e.sigChan)
                        close(e.sigChan)
                        log.Println(pid, "[Common] endless received SIGTERM.")
                        e.Shutdown()
                        return
                case syscall.SIGTSTP:
                        log.Println(pid, "[Common] endless received SIGTSTP.")
                default:
                        log.Printf("[Common] endless received %v: nothing we care about...\n", sig)
                }
                e.signalHooks(PostSignal, sig)
        }
}

func endlessServer.fork

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

func (e *endlessServer) fork() (err error) {
        runningServerReg.Lock()
        defer runningServerReg.Unlock()

        // only one server instance should fork!
        if runningServersForked {
                return errors.New("another process already forked, ignoring this one")
        }

        runningServersForked = true

        var files = make([]*os.File, len(runningServers))
        var orderArgs = make([]string, len(runningServers))
        // get the accessor socket fds for _all_ server instances
        for _, srvPtr := range runningServers {
                // introspect.PrintTypeDump(srvPtr.endlessListener)
                switch srvPtr.endlessListener.(type) {
                case *endlessListener:
                        // normal listener
                        files[socketPtrOffsetMap[srvPtr.Server.Addr]] = srvPtr.endlessListener.(*endlessListener).File()
                default:
                        // tls listener
                        files[socketPtrOffsetMap[srvPtr.Server.Addr]] = srvPtr.tlsInnerListener.File()
                }
                orderArgs[socketPtrOffsetMap[srvPtr.Server.Addr]] = srvPtr.Server.Addr
        }

        env := append(
                os.Environ(),
                "ENDLESS_CONTINUE=1",
        )
        if len(runningServers) > 1 {
                env = append(env, fmt.Sprintf(`ENDLESS_SOCKET_ORDER=%s`, strings.Join(orderArgs, ",")))
        }

        path := os.Args[0]
        var args []string
        if len(os.Args) > 1 {
                args = os.Args[1:]
        }

        cmd := exec.Command(path, args...)
        cmd.Stdout = os.Stdout
        cmd.Stderr = os.Stderr
        cmd.ExtraFiles = files
        cmd.Env = env

        if err = cmd.Start(); err != nil {
                log.Fatalf("%v [Common] endless restart: failed to launch, error: %v", syscall.Getpid(), err)
        }

        return
}

func endlessServer.ListenAndServeTLS

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

func (e *endlessServer) ListenAndServeTLS(certFile, keyFile string) (err error) {
        addr := e.Addr
        if addr == "" {
                addr = ":https"
        }

        // Setup HTTP/2 before srv.Serve, to initialize srv.TLSConfig
        // before we clone it and create the TLS Listener.
        if err = setupHTTP2_ServeTLS(e.Server); err != nil {
                return
        }

        config := new(tls.Config)
        if e.Server.TLSConfig != nil {
                *config = *e.Server.TLSConfig.Clone()
        }
        if !utils.NewSet(config.NextProtos...).Contains("http/1.1") {
                config.NextProtos = append(config.NextProtos, "http/1.1")
        }

        configHasCert := len(config.Certificates) > 0 || config.GetCertificate != nil
        if !configHasCert || certFile != "" || keyFile != "" {
                config.Certificates = make([]tls.Certificate, 1)
                config.Certificates[0], err = tls.LoadX509KeyPair(certFile, keyFile)
                if err != nil {
                        return err
                }
        }

        routine.Go(e.handleSignals, routine.AppName(e.AppName))

        l, err := e.getListener(addr)
        if err != nil {
                log.Println(syscall.Getpid(), "[Common] endless error occur when get listener:", err)
                return
        }

        e.tlsInnerListener = newEndlessListener(l, e)
        e.endlessListener = tls.NewListener(e.tlsInnerListener, config)
        if e.isChild {
                _ = syscallKill(syscall.Getppid())
        }

        return e.Serve()
}

func endlessServer.RegisterSignalHook

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

func (e *endlessServer) RegisterSignalHook(prePost int, sig os.Signal, f func()) (err error) {
        if prePost != PreSignal && prePost != PostSignal {
                err = fmt.Errorf("cannot use %v for prePost arg. Must be endless.PRE_SIGNAL or endless.POST_SIGNAL", sig)
                return
        }
        for _, s := range hookableSignals {
                if s == sig {
                        e.SignalHooks[prePost][sig] = append(e.SignalHooks[prePost][sig], f)
                        return
                }
        }
        err = fmt.Errorf("signal %v is not supported", sig)
        return
}

func endlessServer.signalHooks

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

func (e *endlessServer) signalHooks(ppFlag int, sig os.Signal) {
        if _, notSet := e.SignalHooks[ppFlag][sig]; !notSet {
                return
        }
        for _, f := range e.SignalHooks[ppFlag][sig] {
                f()
        }
}

func endlessListener.File

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

func (e *endlessListener) File() *os.File {
        // returns a dup(2) - FD_CLOEXEC flag *not* set
        tl := e.Listener.(*net.TCPListener)
        fl, _ := tl.File()
        return fl
}

func ListenAndServe

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

132	`func ListenAndServe(appName string, handler http.Handler, addr string, nextProtos []string) error {`
133	`server := NewServer(appName, handler, addr, nextProtos)`
134	`return server.ListenAndServe()`
135	`}`

func ListenAndServeTLS

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

func ListenAndServeTLS(appName string, handler http.Handler, addr, certFile, keyFile string,
        nextProtos []string) error {
        server := NewServer(appName, handler, addr, nextProtos)
        return server.ListenAndServeTLS(certFile, keyFile)
}

func endlessConn.SetKeepAlive

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

581	`func (e *endlessConn) SetKeepAlive(keepalive bool) error {`
582	`return e.Conn.(*net.TCPConn).SetKeepAlive(keepalive)`
583	`}`

func endlessConn.SetKeepAlivePeriod

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

586	`func (e *endlessConn) SetKeepAlivePeriod(d time.Duration) error {`
587	`return e.Conn.(*net.TCPConn).SetKeepAlivePeriod(d)`
588	`}`

func endlessConn.SetNoDelay

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

594	`func (e *endlessConn) SetNoDelay(noDelay bool) error {`
595	`return e.Conn.(*net.TCPConn).SetNoDelay(noDelay)`
596	`}`

func endlessConn.SetLinger

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

575	`func (e *endlessConn) SetLinger(sec int) error {`
576	`return e.Conn.(*net.TCPConn).SetLinger(sec)`
577	`}`

func endlessConn.ReadFrom

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

559	`func (e *endlessConn) ReadFrom(r io.Reader) (int64, error) {`
560	`return e.Conn.(*net.TCPConn).ReadFrom(r)`
561	`}`

func endlessConn.SyscallConn

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

554	`func (e *endlessConn) SyscallConn() (syscall.RawConn, error) {`
555	`return e.Conn.(*net.TCPConn).SyscallConn()`
556	`}`

func endlessConn.SetDeadline

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/endless.go:

538	`func (e *endlessConn) SetDeadline(t time.Time) error { return e.Conn.SetDeadline(t) }`

func syscallKill

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/gracefully/signal_darwin.go:

122	`func syscallKill(ppid int) error {`
123	`return syscall.Kill(ppid, syscall.SIGTERM)`
124	`}`

Package Overview: github.com/wfusion/gofusion/http/middleware 53.3%

Please select a function to see what's left for testing.

`@12:9(...)`	`github.com/wfusion/gofusion/http/middleware/trace.go`	`100.0%`	`7/7`
`@120:9(...)`	`github.com/wfusion/gofusion/http/middleware/logging.go`	`100.0%`	`3/3`
`@29:4(...)`	`github.com/wfusion/gofusion/http/middleware/trace.go`	`100.0%`	`2/2`
`@38:4(...)`	`github.com/wfusion/gofusion/http/middleware/trace.go`	`100.0%`	`2/2`
`@34:4(...)`	`github.com/wfusion/gofusion/http/middleware/trace.go`	`100.0%`	`2/2`
`@18:4(...)`	`github.com/wfusion/gofusion/http/middleware/trace.go`	`100.0%`	`2/2`
`@19:4(...)`	`github.com/wfusion/gofusion/http/middleware/trace.go`	`100.0%`	`2/2`
`Recover(...)`	`github.com/wfusion/gofusion/http/middleware/recover.go`	`100.0%`	`2/2`
`@26:9(...)`	`github.com/wfusion/gofusion/http/middleware/recover.go`	`100.0%`	`2/2`
`@30:4(...)`	`github.com/wfusion/gofusion/http/middleware/trace.go`	`100.0%`	`2/2`
`@17:4(...)`	`github.com/wfusion/gofusion/http/middleware/trace.go`	`100.0%`	`2/2`
`XSS(...)`	`github.com/wfusion/gofusion/http/middleware/xss.go`	`100.0%`	`2/2`
`@23:4(...)`	`github.com/wfusion/gofusion/http/middleware/trace.go`	`100.0%`	`2/2`
`Trace(...)`	`github.com/wfusion/gofusion/http/middleware/trace.go`	`100.0%`	`1/1`
`Logging(...)`	`github.com/wfusion/gofusion/http/middleware/logging.go`	`100.0%`	`1/1`
`Gateway(...)`	`github.com/wfusion/gofusion/http/middleware/gateway.go`	`100.0%`	`1/1`
`Cors(...)`	`github.com/wfusion/gofusion/http/middleware/cors.go`	`100.0%`	`1/1`
`metricsLogging(...)`	`github.com/wfusion/gofusion/http/middleware/logging.go`	`78.6%`	`11/14`
`logging(...)`	`github.com/wfusion/gofusion/http/middleware/logging.go`	`78.6%`	`11/14`
`@12:9(...)`	`github.com/wfusion/gofusion/http/middleware/cors.go`	`63.2%`	`12/19`
`@27:9(...)`	`github.com/wfusion/gofusion/http/middleware/recover.go`	`60.5%`	`23/38`
`@22:9(...)`	`github.com/wfusion/gofusion/http/middleware/xss.go`	`12.1%`	`4/33`
`xssFilterJSON(...)`	`github.com/wfusion/gofusion/http/middleware/xss.go`	`0.0%`	`0/9`
`xssFilterJSONData(...)`	`github.com/wfusion/gofusion/http/middleware/xss.go`	`0.0%`	`0/9`
`xssFilterQuery(...)`	`github.com/wfusion/gofusion/http/middleware/xss.go`	`0.0%`	`0/8`
`xssFilterPlain(...)`	`github.com/wfusion/gofusion/http/middleware/xss.go`	`0.0%`	`0/2`

func @12:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/middleware/trace.go:

func(c *gin.Context) {
                var (
                        userID, traceID string
                )
                utils.IfAny(
                        func() bool { traceID = c.GetHeader(fusCtx.KeyTraceID); return traceID != "" },
                        func() bool { traceID = c.GetHeader("HTTP_TRACE_ID"); return traceID != "" },
                        func() bool {
                                traceID = utils.LookupByFuzzyKeyword[string](c.GetHeader, "trace_id")
                                return traceID != ""
                        },
                        func() bool { traceID = utils.NginxID(); return traceID != "" },
                )
                c.Header("Trace-Id", traceID)
                c.Set(fusCtx.KeyTraceID, traceID)

                utils.IfAny(
                        func() bool { userID = c.GetHeader(fusCtx.KeyUserID); return userID != "" },
                        func() bool {
                                userID = utils.LookupByFuzzyKeyword[string](c.GetHeader, "user_id")
                                return userID != ""
                        },
                        func() bool {
                                userID = utils.LookupByFuzzyKeyword[string](c.GetQuery, "user_id")
                                return userID != ""
                        },
                        func() bool {
                                userID = utils.LookupByFuzzyKeyword[string](c.GetPostForm, "user_id")
                                return userID != ""
                        },
                )
                c.Set(fusCtx.KeyUserID, userID)
                c.Next()
        }

func @120:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/middleware/logging.go:

func(c *gin.Context) {
                reqURL := clone.Clone(c.Request.URL)
                defer logging(ctx, c, logger, reqURL, appName)

                c.Next()
        }

func @29:4

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/middleware/trace.go:

29	`func() bool { userID = c.GetHeader(fusCtx.KeyUserID); return userID != "" }`

func @38:4

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/middleware/trace.go:

38	`func() bool {`
39	`userID = utils.LookupByFuzzyKeyword[string](c.GetPostForm, "user_id")`
40	`return userID != ""`
41	`}`

func @34:4

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/middleware/trace.go:

34	`func() bool {`
35	`userID = utils.LookupByFuzzyKeyword[string](c.GetQuery, "user_id")`
36	`return userID != ""`
37	`}`

func @18:4

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/middleware/trace.go:

18	`func() bool { traceID = c.GetHeader("HTTP_TRACE_ID"); return traceID != "" }`

func @19:4

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/middleware/trace.go:

19	`func() bool {`
20	`traceID = utils.LookupByFuzzyKeyword[string](c.GetHeader, "trace_id")`
21	`return traceID != ""`
22	`}`

func Recover

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/middleware/recover.go:

func Recover(appName string, logger resty.Logger) gin.HandlerFunc {
        tag := i18n.DefaultLang(i18n.AppName(appName))
        return func(c *gin.Context) {
                defer func() {
                        if err := recover(); err != nil {
                                // Check for a broken connection, as it is not really a
                                // condition that warrants a panic stack trace.
                                var brokenPipe bool
                                if ne, ok := err.(*net.OpError); ok {
                                        if se, ok := ne.Err.(*os.SyscallError); ok {
                                                if strings.Contains(strings.ToLower(se.Error()), "broken pipe") ||
                                                        strings.Contains(strings.ToLower(se.Error()), "connection reset by peer") {
                                                        brokenPipe = true
                                                }
                                        }
                                }
                                if brokenPipe {
                                        c.Abort()
                                        return
                                }
                                debugStack := ""
                                for _, v := range strings.Split(string(debug.Stack()), "\n") {
                                        debugStack += "> " + v + "\n"
                                }
                                hostname, hostnameErr := os.Hostname()
                                if hostnameErr != nil {
                                        hostname = "unknown"
                                }
                                buffer, cb := utils.BytesBufferPool.Get(nil)
                                defer cb()

                                if tag == language.Chinese {
                                        buffer.WriteString(fmt.Sprintf("%v \n", err))
                                        buffer.WriteString(fmt.Sprintf("请求时间：%v \n", time.Now().Format(constant.StdTimeLayout)))
                                        buffer.WriteString(fmt.Sprintf("主机名称：%v \n", hostname))
                                        buffer.WriteString(fmt.Sprintf("请求编号：%v \n", c.GetString(fusCtx.KeyTraceID)))
                                        buffer.WriteString(fmt.Sprintf("请求地址：%v \n",
                                                c.Request.Method+"  "+c.Request.Host+c.Request.RequestURI))
                                        buffer.WriteString(fmt.Sprintf("请求UA：%v \n", c.Request.UserAgent()))
                                        buffer.WriteString(fmt.Sprintf("请求IP：%v \n", c.ClientIP()))
                                        buffer.WriteString(fmt.Sprintf("异常捕获：\n%v", debugStack))
                                } else {
                                        buffer.WriteString(fmt.Sprintf("%v \n", err))
                                        buffer.WriteString(fmt.Sprintf("RequstTime：%v \n", time.Now().Format(constant.StdTimeLayout)))
                                        buffer.WriteString(fmt.Sprintf("Hostname：%v \n", hostname))
                                        buffer.WriteString(fmt.Sprintf("TraceID：%v \n", c.GetString(fusCtx.KeyTraceID)))
                                        buffer.WriteString(fmt.Sprintf("RequestURI：%v \n",
                                                c.Request.Method+"  "+c.Request.Host+c.Request.RequestURI))
                                        buffer.WriteString(fmt.Sprintf("UA：%v \n", c.Request.UserAgent()))
                                        buffer.WriteString(fmt.Sprintf("IP：%v \n", c.ClientIP()))
                                        buffer.WriteString(fmt.Sprintf("ErrorStack：\n%v", debugStack))
                                }

                                if logger != nil {
                                        logger.Errorf(buffer.String(), fusCtx.New(fusCtx.Gin(c)))
                                } else {
                                        log.Printf(buffer.String())
                                }

                                c.AbortWithStatusJSON(http.StatusInternalServerError, map[string]any{
                                        "code":    http.StatusInternalServerError,
                                        "message": "service internal error",
                                })
                        }
                }()
                c.Next()
        }
}

func @26:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/middleware/recover.go:

func(c *gin.Context) {
                defer func() {
                        if err := recover(); err != nil {
                                // Check for a broken connection, as it is not really a
                                // condition that warrants a panic stack trace.
                                var brokenPipe bool
                                if ne, ok := err.(*net.OpError); ok {
                                        if se, ok := ne.Err.(*os.SyscallError); ok {
                                                if strings.Contains(strings.ToLower(se.Error()), "broken pipe") ||
                                                        strings.Contains(strings.ToLower(se.Error()), "connection reset by peer") {
                                                        brokenPipe = true
                                                }
                                        }
                                }
                                if brokenPipe {
                                        c.Abort()
                                        return
                                }
                                debugStack := ""
                                for _, v := range strings.Split(string(debug.Stack()), "\n") {
                                        debugStack += "> " + v + "\n"
                                }
                                hostname, hostnameErr := os.Hostname()
                                if hostnameErr != nil {
                                        hostname = "unknown"
                                }
                                buffer, cb := utils.BytesBufferPool.Get(nil)
                                defer cb()

                                if tag == language.Chinese {
                                        buffer.WriteString(fmt.Sprintf("%v \n", err))
                                        buffer.WriteString(fmt.Sprintf("请求时间：%v \n", time.Now().Format(constant.StdTimeLayout)))
                                        buffer.WriteString(fmt.Sprintf("主机名称：%v \n", hostname))
                                        buffer.WriteString(fmt.Sprintf("请求编号：%v \n", c.GetString(fusCtx.KeyTraceID)))
                                        buffer.WriteString(fmt.Sprintf("请求地址：%v \n",
                                                c.Request.Method+"  "+c.Request.Host+c.Request.RequestURI))
                                        buffer.WriteString(fmt.Sprintf("请求UA：%v \n", c.Request.UserAgent()))
                                        buffer.WriteString(fmt.Sprintf("请求IP：%v \n", c.ClientIP()))
                                        buffer.WriteString(fmt.Sprintf("异常捕获：\n%v", debugStack))
                                } else {
                                        buffer.WriteString(fmt.Sprintf("%v \n", err))
                                        buffer.WriteString(fmt.Sprintf("RequstTime：%v \n", time.Now().Format(constant.StdTimeLayout)))
                                        buffer.WriteString(fmt.Sprintf("Hostname：%v \n", hostname))
                                        buffer.WriteString(fmt.Sprintf("TraceID：%v \n", c.GetString(fusCtx.KeyTraceID)))
                                        buffer.WriteString(fmt.Sprintf("RequestURI：%v \n",
                                                c.Request.Method+"  "+c.Request.Host+c.Request.RequestURI))
                                        buffer.WriteString(fmt.Sprintf("UA：%v \n", c.Request.UserAgent()))
                                        buffer.WriteString(fmt.Sprintf("IP：%v \n", c.ClientIP()))
                                        buffer.WriteString(fmt.Sprintf("ErrorStack：\n%v", debugStack))
                                }

                                if logger != nil {
                                        logger.Errorf(buffer.String(), fusCtx.New(fusCtx.Gin(c)))
                                } else {
                                        log.Printf(buffer.String())
                                }

                                c.AbortWithStatusJSON(http.StatusInternalServerError, map[string]any{
                                        "code":    http.StatusInternalServerError,
                                        "message": "service internal error",
                                })
                        }
                }()
                c.Next()
        }

func @30:4

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/middleware/trace.go:

30	`func() bool {`
31	`userID = utils.LookupByFuzzyKeyword[string](c.GetHeader, "user_id")`
32	`return userID != ""`
33	`}`

func @17:4

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/middleware/trace.go:

17	`func() bool { traceID = c.GetHeader(fusCtx.KeyTraceID); return traceID != "" }`

func XSS

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/middleware/xss.go:

func XSS(whitelistURLs []string) gin.HandlerFunc {
        // Do this once for each unique policy, and use the policy for the life of the
        // program Policy creation/editing is not safe to use in multiple goroutines.
        p := bluemonday.UGCPolicy()

        return func(c *gin.Context) {
                for _, u := range whitelistURLs {
                        if strings.HasPrefix(c.Request.URL.String(), u) {
                                c.Next()
                                return
                        }
                }

                sanitizedQuery, err := xssFilterQuery(p, c.Request.URL.RawQuery)
                if err != nil {
                        err = errors.Wrap(err, "filter query")
                        _ = c.Error(err)
                        c.Abort()
                        return
                }
                c.Request.URL.RawQuery = sanitizedQuery

                var sanitizedBody string
                body, err := c.GetRawData()
                if err != nil {
                        err = errors.Wrap(err, "read body")
                        _ = c.Error(err)
                        c.Abort()
                        return
                }

                // xssFilterJSON() will return error when body is empty.
                if len(body) == 0 {
                        c.Next()
                        return
                }

                switch binding.Default(c.Request.Method, c.ContentType()) {
                case binding.JSON:
                        if sanitizedBody, err = xssFilterJSON(p, string(body)); err != nil {
                                err = errors.Wrap(err, "filter json")
                        }
                case binding.FormMultipart:
                        sanitizedBody = xssFilterPlain(p, string(body))
                case binding.Form:
                        if sanitizedBody, err = xssFilterQuery(p, string(body)); err != nil {
                                err = errors.Wrap(err, "filter form")
                        }
                }
                if err != nil {
                        _ = c.Error(err)
                        c.Abort()
                        return
                }

                c.Request.Body = ioutil.NopCloser(strings.NewReader(sanitizedBody))
                c.Next()
        }
}

func @23:4

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/middleware/trace.go:

23	`func() bool { traceID = utils.NginxID(); return traceID != "" }`

func Trace

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/middleware/trace.go:

func Trace() gin.HandlerFunc {
        return func(c *gin.Context) {
                var (
                        userID, traceID string
                )
                utils.IfAny(
                        func() bool { traceID = c.GetHeader(fusCtx.KeyTraceID); return traceID != "" },
                        func() bool { traceID = c.GetHeader("HTTP_TRACE_ID"); return traceID != "" },
                        func() bool {
                                traceID = utils.LookupByFuzzyKeyword[string](c.GetHeader, "trace_id")
                                return traceID != ""
                        },
                        func() bool { traceID = utils.NginxID(); return traceID != "" },
                )
                c.Header("Trace-Id", traceID)
                c.Set(fusCtx.KeyTraceID, traceID)

                utils.IfAny(
                        func() bool { userID = c.GetHeader(fusCtx.KeyUserID); return userID != "" },
                        func() bool {
                                userID = utils.LookupByFuzzyKeyword[string](c.GetHeader, "user_id")
                                return userID != ""
                        },
                        func() bool {
                                userID = utils.LookupByFuzzyKeyword[string](c.GetQuery, "user_id")
                                return userID != ""
                        },
                        func() bool {
                                userID = utils.LookupByFuzzyKeyword[string](c.GetPostForm, "user_id")
                                return userID != ""
                        },
                )
                c.Set(fusCtx.KeyUserID, userID)
                c.Next()
        }
}

func Logging

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/middleware/logging.go:

func Logging(ctx context.Context, appName string, logger resty.Logger) gin.HandlerFunc {
        return func(c *gin.Context) {
                reqURL := clone.Clone(c.Request.URL)
                defer logging(ctx, c, logger, reqURL, appName)

                c.Next()
        }

}

func Gateway

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/middleware/gateway.go:

9	`func Gateway(c *gin.Context) {`
10	`consts.SetReqStartTime(c)`
11	`}`

func Cors

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/middleware/cors.go:

func Cors() gin.HandlerFunc {
        return func(c *gin.Context) {
                origin := c.Request.Header.Get("Origin")
                var headerKeys []string
                for k := range c.Request.Header {
                        headerKeys = append(headerKeys, k)
                }
                corsHeader := c.GetHeader("Access-Control-Request-Headers")
                headerKeys = append(headerKeys, strings.Split(corsHeader, ",")...)

                headerStr := strings.Join(headerKeys, ", ")
                if headerStr != "" {
                        headerStr = fmt.Sprintf("access-control-allow-origin, access-control-allow-headers, %s", headerStr)
                } else {
                        headerStr = "access-control-allow-origin, access-control-allow-headers"
                }
                if origin != "" {
                        c.Writer.Header().Set("Access-Control-Allow-Origin", origin)
                        c.Writer.Header().Set("Access-Control-Allow-Headers", headerStr)
                        c.Writer.Header().Set("Access-Control-Allow-Methods", "POST, OPTIONS, GET, PUT, DELETE")
                        c.Writer.Header().Set("Access-Control-Expose-Headers",
                                "Content-Length, Access-Control-Allow-Origin, Access-Control-Allow-Headers, Content-Type")
                        c.Writer.Header().Set("Access-Control-Allow-Credentials", "true")
                }

                if c.Request.Method == "OPTIONS" {
                        c.AbortWithStatusJSON(http.StatusNoContent, "no content")
                }
                c.Next()
        }
}

func metricsLogging

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/middleware/logging.go:

func metricsLogging(ctx context.Context, appName, path, method string,
        status, rspSize int, reqSize int64, cost float64) {
        select {
        case <-ctx.Done():
                return
        default:

        }

        labels := []metrics.Label{
                {Key: "path", Value: path},
                {Key: "method", Value: method},
                {Key: "status", Value: cast.ToString(status)},
                {Key: "req_size", Value: cast.ToString(reqSize)},
                {Key: "rsp_size", Value: cast.ToString(rspSize)},
        }
        app := config.Use(appName).AppName()
        latencyKey := append([]string{app}, metricsLatencyKey...)
        totalKey := append([]string{app}, metricsTotalKey...)
        for _, m := range metrics.Internal(metrics.AppName(appName)) {
                select {
                case <-ctx.Done():
                        return
                default:
                        if m.IsEnableServiceLabel() {
                                m.IncrCounter(ctx, totalKey, 1, metrics.Labels(labels))
                                m.AddSample(ctx, latencyKey, cost, metrics.Labels(labels),
                                        metrics.PrometheusBuckets(metricsLatencyBuckets))
                        } else {
                                m.IncrCounter(ctx, metricsTotalKey, 1, metrics.Labels(labels))
                                m.AddSample(ctx, metricsLatencyKey, cost, metrics.Labels(labels),
                                        metrics.PrometheusBuckets(metricsLatencyBuckets))
                        }
                }
        }
}

func logging

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/middleware/logging.go:

func logging(rootCtx context.Context, c *gin.Context, logger resty.Logger, rawURL *url.URL, appName string) {
        ctx := fusCtx.New(fusCtx.Gin(c))
        cost := float64(consts.GetReqCost(c)) / float64(time.Millisecond)
        status := c.Writer.Status()
        fields := fusLog.Fields{
                "path":        rawURL.Path,
                "method":      c.Request.Method,
                "status":      status,
                "referer":     c.Request.Referer(),
                "req_size":    c.Request.ContentLength,
                "rsp_size":    c.Writer.Size(),
                "cost":        cost,
                "user_agent":  c.Request.UserAgent(),
                "client_addr": c.ClientIP(),
        }

        // skip health check logging
        if rawURL.Path == "/health" && c.Request.Method == http.MethodGet {
                return
        }

        msg := fmt.Sprintf(
                "%s -> %s %s %d %d %d (%.2fms)",
                c.ClientIP(), utils.LocalIP.String(),
                strconv.Quote(fmt.Sprintf("%s %s", c.Request.Method, rawURL)),
                c.Request.ContentLength, c.Writer.Size(), status, cost,
        )

        if logger != nil {
                switch {
                case status < http.StatusBadRequest:
                        logger.Debugf(msg, ctx, fields)
                case status >= http.StatusBadRequest && status < http.StatusInternalServerError:
                        logger.Warnf(msg, ctx, fields)
                default:
                        logger.Errorf(msg, ctx, fields)
                }
        } else {
                log.Printf(msg+" %s", utils.MustJsonMarshal(fields))
        }

        go metricsLogging(rootCtx, appName, rawURL.Path, c.Request.Method, status,
                c.Writer.Size(), c.Request.ContentLength, cost)
}

func @12:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/middleware/cors.go:

func(c *gin.Context) {
                origin := c.Request.Header.Get("Origin")
                var headerKeys []string
                for k := range c.Request.Header {
                        headerKeys = append(headerKeys, k)
                }
                corsHeader := c.GetHeader("Access-Control-Request-Headers")
                headerKeys = append(headerKeys, strings.Split(corsHeader, ",")...)

                headerStr := strings.Join(headerKeys, ", ")
                if headerStr != "" {
                        headerStr = fmt.Sprintf("access-control-allow-origin, access-control-allow-headers, %s", headerStr)
                } else {
                        headerStr = "access-control-allow-origin, access-control-allow-headers"
                }
                if origin != "" {
                        c.Writer.Header().Set("Access-Control-Allow-Origin", origin)
                        c.Writer.Header().Set("Access-Control-Allow-Headers", headerStr)
                        c.Writer.Header().Set("Access-Control-Allow-Methods", "POST, OPTIONS, GET, PUT, DELETE")
                        c.Writer.Header().Set("Access-Control-Expose-Headers",
                                "Content-Length, Access-Control-Allow-Origin, Access-Control-Allow-Headers, Content-Type")
                        c.Writer.Header().Set("Access-Control-Allow-Credentials", "true")
                }

                if c.Request.Method == "OPTIONS" {
                        c.AbortWithStatusJSON(http.StatusNoContent, "no content")
                }
                c.Next()
        }

func @27:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/middleware/recover.go:

func() {
                        if err := recover(); err != nil {
                                // Check for a broken connection, as it is not really a
                                // condition that warrants a panic stack trace.
                                var brokenPipe bool
                                if ne, ok := err.(*net.OpError); ok {
                                        if se, ok := ne.Err.(*os.SyscallError); ok {
                                                if strings.Contains(strings.ToLower(se.Error()), "broken pipe") ||
                                                        strings.Contains(strings.ToLower(se.Error()), "connection reset by peer") {
                                                        brokenPipe = true
                                                }
                                        }
                                }
                                if brokenPipe {
                                        c.Abort()
                                        return
                                }
                                debugStack := ""
                                for _, v := range strings.Split(string(debug.Stack()), "\n") {
                                        debugStack += "> " + v + "\n"
                                }
                                hostname, hostnameErr := os.Hostname()
                                if hostnameErr != nil {
                                        hostname = "unknown"
                                }
                                buffer, cb := utils.BytesBufferPool.Get(nil)
                                defer cb()

                                if tag == language.Chinese {
                                        buffer.WriteString(fmt.Sprintf("%v \n", err))
                                        buffer.WriteString(fmt.Sprintf("请求时间：%v \n", time.Now().Format(constant.StdTimeLayout)))
                                        buffer.WriteString(fmt.Sprintf("主机名称：%v \n", hostname))
                                        buffer.WriteString(fmt.Sprintf("请求编号：%v \n", c.GetString(fusCtx.KeyTraceID)))
                                        buffer.WriteString(fmt.Sprintf("请求地址：%v \n",
                                                c.Request.Method+"  "+c.Request.Host+c.Request.RequestURI))
                                        buffer.WriteString(fmt.Sprintf("请求UA：%v \n", c.Request.UserAgent()))
                                        buffer.WriteString(fmt.Sprintf("请求IP：%v \n", c.ClientIP()))
                                        buffer.WriteString(fmt.Sprintf("异常捕获：\n%v", debugStack))
                                } else {
                                        buffer.WriteString(fmt.Sprintf("%v \n", err))
                                        buffer.WriteString(fmt.Sprintf("RequstTime：%v \n", time.Now().Format(constant.StdTimeLayout)))
                                        buffer.WriteString(fmt.Sprintf("Hostname：%v \n", hostname))
                                        buffer.WriteString(fmt.Sprintf("TraceID：%v \n", c.GetString(fusCtx.KeyTraceID)))
                                        buffer.WriteString(fmt.Sprintf("RequestURI：%v \n",
                                                c.Request.Method+"  "+c.Request.Host+c.Request.RequestURI))
                                        buffer.WriteString(fmt.Sprintf("UA：%v \n", c.Request.UserAgent()))
                                        buffer.WriteString(fmt.Sprintf("IP：%v \n", c.ClientIP()))
                                        buffer.WriteString(fmt.Sprintf("ErrorStack：\n%v", debugStack))
                                }

                                if logger != nil {
                                        logger.Errorf(buffer.String(), fusCtx.New(fusCtx.Gin(c)))
                                } else {
                                        log.Printf(buffer.String())
                                }

                                c.AbortWithStatusJSON(http.StatusInternalServerError, map[string]any{
                                        "code":    http.StatusInternalServerError,
                                        "message": "service internal error",
                                })
                        }
                }

func @22:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/middleware/xss.go:

func(c *gin.Context) {
                for _, u := range whitelistURLs {
                        if strings.HasPrefix(c.Request.URL.String(), u) {
                                c.Next()
                                return
                        }
                }

                sanitizedQuery, err := xssFilterQuery(p, c.Request.URL.RawQuery)
                if err != nil {
                        err = errors.Wrap(err, "filter query")
                        _ = c.Error(err)
                        c.Abort()
                        return
                }
                c.Request.URL.RawQuery = sanitizedQuery

                var sanitizedBody string
                body, err := c.GetRawData()
                if err != nil {
                        err = errors.Wrap(err, "read body")
                        _ = c.Error(err)
                        c.Abort()
                        return
                }

                // xssFilterJSON() will return error when body is empty.
                if len(body) == 0 {
                        c.Next()
                        return
                }

                switch binding.Default(c.Request.Method, c.ContentType()) {
                case binding.JSON:
                        if sanitizedBody, err = xssFilterJSON(p, string(body)); err != nil {
                                err = errors.Wrap(err, "filter json")
                        }
                case binding.FormMultipart:
                        sanitizedBody = xssFilterPlain(p, string(body))
                case binding.Form:
                        if sanitizedBody, err = xssFilterQuery(p, string(body)); err != nil {
                                err = errors.Wrap(err, "filter form")
                        }
                }
                if err != nil {
                        _ = c.Error(err)
                        c.Abort()
                        return
                }

                c.Request.Body = ioutil.NopCloser(strings.NewReader(sanitizedBody))
                c.Next()
        }

func xssFilterJSON

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/middleware/xss.go:

func xssFilterJSON(p *bluemonday.Policy, s string) (string, error) {
        var data any
        if err := json.Unmarshal([]byte(s), &data); err != nil {
                return "", err
        }

        b := strings.Builder{}
        e := json.NewEncoder(&b)
        e.SetEscapeHTML(false)
        if err := e.Encode(xssFilterJSONData(p, data)); err != nil {
                return "", err
        }
        // use `TrimSpace` to trim newline char add by `Encode`.
        return strings.TrimSpace(b.String()), nil
}

func xssFilterJSONData

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/middleware/xss.go:

func xssFilterJSONData(p *bluemonday.Policy, d any) any {
        switch data := d.(type) {
        case []any:
                for i, v := range data {
                        data[i] = xssFilterJSONData(p, v)
                }
                return data
        case map[string]any:
                for k, v := range data {
                        data[k] = xssFilterJSONData(p, v)
                }
                return data
        case string:
                return xssFilterPlain(p, data)
        default:
                return data
        }
}

func xssFilterQuery

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/middleware/xss.go:

func xssFilterQuery(p *bluemonday.Policy, s string) (string, error) {
        values, err := url.ParseQuery(s)
        if err != nil {
                return "", err
        }

        for k, v := range values {
                values.Del(k)
                for _, vv := range v {
                        values.Add(k, xssFilterPlain(p, vv))
                }
        }

        return values.Encode(), nil
}

func xssFilterPlain

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/middleware/xss.go:

128	`func xssFilterPlain(p *bluemonday.Policy, s string) string {`
129	`sanitized := p.Sanitize(s)`
130	`return html.UnescapeString(sanitized)`
131	`}`

Package Overview: github.com/wfusion/gofusion/http/parser 47.4%

Please select a function to see what's left for testing.

`MapFormByTag(...)`	`github.com/wfusion/gofusion/http/parser/form_mapping.go`	`100.0%`	`10/10`
`mappingByPtr(...)`	`github.com/wfusion/gofusion/http/parser/form_mapping.go`	`100.0%`	`2/2`
`ApplicationFormUrlencodedParser.PreParse(...)`	`github.com/wfusion/gofusion/http/parser/application_x_www_form_urlencoded.go`	`100.0%`	`1/1`
`formSource.TrySet(...)`	`github.com/wfusion/gofusion/http/parser/form_mapping.go`	`100.0%`	`1/1`
`MultipartFormDataParser.transformField(...)`	`github.com/wfusion/gofusion/http/parser/multipart_formdata.go`	`92.3%`	`12/13`
`mapping(...)`	`github.com/wfusion/gofusion/http/parser/form_mapping.go`	`85.3%`	`29/34`
`setSlice(...)`	`github.com/wfusion/gofusion/http/parser/form_mapping.go`	`83.3%`	`5/6`
`setIntField(...)`	`github.com/wfusion/gofusion/http/parser/form_mapping.go`	`83.3%`	`5/6`
`MultipartFormDataParser.lookupFieldByTag(...)`	`github.com/wfusion/gofusion/http/parser/multipart_formdata.go`	`83.3%`	`5/6`
`setArray(...)`	`github.com/wfusion/gofusion/http/parser/form_mapping.go`	`80.0%`	`4/5`
`MultipartFormDataParser.PreParse(...)`	`github.com/wfusion/gofusion/http/parser/multipart_formdata.go`	`80.0%`	`4/5`
`GetByContentType(...)`	`github.com/wfusion/gofusion/http/parser/parser.go`	`75.0%`	`3/4`
`head(...)`	`github.com/wfusion/gofusion/http/parser/form_mapping.go`	`75.0%`	`3/4`
`tryToSetValue(...)`	`github.com/wfusion/gofusion/http/parser/form_mapping.go`	`73.3%`	`11/15`
`MultipartFormDataParser.Parse(...)`	`github.com/wfusion/gofusion/http/parser/multipart_formdata.go`	`72.0%`	`18/25`
`ApplicationFormUrlencodedParser.Parse(...)`	`github.com/wfusion/gofusion/http/parser/application_x_www_form_urlencoded.go`	`71.4%`	`5/7`
`setByForm(...)`	`github.com/wfusion/gofusion/http/parser/form_mapping.go`	`61.1%`	`11/18`
`setFormMap(...)`	`github.com/wfusion/gofusion/http/parser/form_mapping.go`	`58.8%`	`10/17`
`@48:8(...)`	`github.com/wfusion/gofusion/http/parser/multipart_formdata.go`	`50.0%`	`1/2`
`setWithProperType(...)`	`github.com/wfusion/gofusion/http/parser/form_mapping.go`	`17.4%`	`4/23`
`setTimeField(...)`	`github.com/wfusion/gofusion/http/parser/form_mapping.go`	`0.0%`	`0/29`
`setFloatField(...)`	`github.com/wfusion/gofusion/http/parser/form_mapping.go`	`0.0%`	`0/6`
`setBoolField(...)`	`github.com/wfusion/gofusion/http/parser/form_mapping.go`	`0.0%`	`0/6`
`setUintField(...)`	`github.com/wfusion/gofusion/http/parser/form_mapping.go`	`0.0%`	`0/6`
`setTimeDuration(...)`	`github.com/wfusion/gofusion/http/parser/form_mapping.go`	`0.0%`	`0/5`
`@105:20(...)`	`github.com/wfusion/gofusion/http/parser/multipart_formdata.go`	`0.0%`	`0/3`
`@100:20(...)`	`github.com/wfusion/gofusion/http/parser/multipart_formdata.go`	`0.0%`	`0/3`
`@101:20(...)`	`github.com/wfusion/gofusion/http/parser/multipart_formdata.go`	`0.0%`	`0/3`
`@102:20(...)`	`github.com/wfusion/gofusion/http/parser/multipart_formdata.go`	`0.0%`	`0/3`
`@103:20(...)`	`github.com/wfusion/gofusion/http/parser/multipart_formdata.go`	`0.0%`	`0/3`
`@104:20(...)`	`github.com/wfusion/gofusion/http/parser/multipart_formdata.go`	`0.0%`	`0/3`
`@99:20(...)`	`github.com/wfusion/gofusion/http/parser/multipart_formdata.go`	`0.0%`	`0/3`
`@106:20(...)`	`github.com/wfusion/gofusion/http/parser/multipart_formdata.go`	`0.0%`	`0/3`
`@107:20(...)`	`github.com/wfusion/gofusion/http/parser/multipart_formdata.go`	`0.0%`	`0/3`
`@108:20(...)`	`github.com/wfusion/gofusion/http/parser/multipart_formdata.go`	`0.0%`	`0/3`
`@109:20(...)`	`github.com/wfusion/gofusion/http/parser/multipart_formdata.go`	`0.0%`	`0/3`
`@110:20(...)`	`github.com/wfusion/gofusion/http/parser/multipart_formdata.go`	`0.0%`	`0/3`
`ApplicationJsonParser.Parse(...)`	`github.com/wfusion/gofusion/http/parser/application_json.go`	`0.0%`	`0/3`
`@112:20(...)`	`github.com/wfusion/gofusion/http/parser/multipart_formdata.go`	`0.0%`	`0/3`
`@111:20(...)`	`github.com/wfusion/gofusion/http/parser/multipart_formdata.go`	`0.0%`	`0/3`
`ApplicationJsonParser.PreParse(...)`	`github.com/wfusion/gofusion/http/parser/application_json.go`	`0.0%`	`0/1`
`malformedRequest(...)`	`github.com/wfusion/gofusion/http/parser/parser.go`	`0.0%`	`0/1`
`unsupportedContentType(...)`	`github.com/wfusion/gofusion/http/parser/parser.go`	`0.0%`	`0/1`

func MapFormByTag

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/form_mapping.go:

func MapFormByTag(ptr any, form map[string][]string, tag string) error {
        // Check if ptr is a map
        ptrVal := reflect.ValueOf(ptr)
        var pointed any
        if ptrVal.Kind() == reflect.Ptr {
                ptrVal = ptrVal.Elem()
                pointed = ptr
        }
        if ptrVal.Type() == mapStringInterfaceSliceType ||
                (ptrVal.Kind() == reflect.Map && ptrVal.Type().Key().Kind() == reflect.String) {
                if pointed != nil {
                        ptr = pointed
                }
                return setFormMap(ptr, form)
        }

        return mappingByPtr(ptr, formSource(form), tag)
}

func mappingByPtr

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/form_mapping.go:

62	`func mappingByPtr(ptr any, setter setter, tag string) error {`
63	`_, err := mapping(reflect.ValueOf(ptr), emptyField, setter, tag)`
64	`return err`
65	`}`

func ApplicationFormUrlencodedParser.PreParse

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/application_x_www_form_urlencoded.go:

11	`func (a *ApplicationFormUrlencodedParser) PreParse(args map[string]string) error {`
12	`return nil`
13	`}`

func formSource.TrySet

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/form_mapping.go:

57	`func (form formSource) TrySet(value reflect.Value, field reflect.StructField,`
58	`tagValue string, opt setOptions) (isSetted bool, err error) {`
59	`return setByForm(value, field, form, tagValue, opt)`
60	`}`

func MultipartFormDataParser.transformField

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/multipart_formdata.go:

func (m *MultipartFormDataParser) transformField(f reflect.Value, param []byte) (err error) {
        ft := f.Type()
        if ft.Kind() == reflect.Ptr {
                ft = ft.Elem()
                if f.IsNil() {
                        f.Set(reflect.New(ft))
                }
                f = f.Elem()
        }

        if byteSliceType.ConvertibleTo(ft) {
                f.Set(reflect.ValueOf(param).Convert(ft))
                return
        }

        caster, ok := castReflectTypeMap[ft.Kind()]
        if !ok {
                return json.Unmarshal(param, f.Addr().Interface())
        }

        return caster(f, param)
}

func mapping

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/form_mapping.go:

func mapping(value reflect.Value, field reflect.StructField, setter setter, tag string) (bool, error) {
        if field.Tag.Get(tag) == "-" { // just ignoring this field
                return false, nil
        }

        var vKind = value.Kind()

        if vKind == reflect.Ptr {
                var isNew bool
                vPtr := value
                if value.IsNil() {
                        isNew = true
                        vPtr = reflect.New(value.Type().Elem())
                }
                isSetted, err := mapping(vPtr.Elem(), field, setter, tag)
                if err != nil {
                        return false, err
                }
                if isNew && isSetted {
                        value.Set(vPtr)
                }
                return isSetted, nil
        }

        if vKind != reflect.Struct || !field.Anonymous {
                ok, err := tryToSetValue(value, field, setter, tag)
                if err != nil {
                        return false, err
                }
                if ok {
                        return true, nil
                }
        }

        if vKind == reflect.Struct {
                tValue := value.Type()

                var isSetted bool
                for i := 0; i < value.NumField(); i++ {
                        sf := tValue.Field(i)
                        if sf.PkgPath != "" && !sf.Anonymous { // unexported
                                continue
                        }
                        ok, err := mapping(value.Field(i), tValue.Field(i), setter, tag)
                        if err != nil {
                                return false, err
                        }
                        isSetted = isSetted || ok
                }
                return isSetted, nil
        }
        return false, nil
}

func setSlice

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/form_mapping.go:

func setSlice(vals []string, value reflect.Value, field reflect.StructField) error {
        slice := reflect.MakeSlice(value.Type(), len(vals), len(vals))
        err := setArray(vals, slice, field)
        if err != nil {
                return err
        }
        value.Set(slice)
        return nil
}

func setIntField

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/form_mapping.go:

func setIntField(val string, bitSize int, field reflect.Value) error {
        if val == "" {
                val = "0"
        }
        intVal, err := strconv.ParseInt(val, 10, bitSize)
        if err == nil {
                field.SetInt(intVal)
        }
        return err
}

func MultipartFormDataParser.lookupFieldByTag

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/multipart_formdata.go:

func (m *MultipartFormDataParser) lookupFieldByTag(t reflect.Type, key, tag string) (fNum int) {
        n := t.NumField()
        for i := 0; i < n; i++ {
                f := t.Field(i)
                if v, ok := f.Tag.Lookup(tag); ok && v == key {
                        return i
                }
        }
        return -1
}

func setArray

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/form_mapping.go:

func setArray(vals []string, value reflect.Value, field reflect.StructField) error {
        for i, s := range vals {
                err := setWithProperType(s, value.Index(i), field)
                if err != nil {
                        return err
                }
        }
        return nil
}

func MultipartFormDataParser.PreParse

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/multipart_formdata.go:

func (m *MultipartFormDataParser) PreParse(args map[string]string) error {
        boundary, ok := args[keyBoundary]
        if !ok {
                return malformedRequest("missing boundary in multipart/form-data")
        }
        m.boundary = boundary
        return nil
}

func GetByContentType

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/parser.go:

func GetByContentType(typ string) (parser Parser, err error) {
        parserType, ok := parserMap[typ]
        if !ok {
                return nil, unsupportedContentType(typ)
        }

        return reflect.New(parserType.Elem()).Interface().(Parser), nil
}

func head

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/form_mapping.go:

func head(str, sep string) (head string, tail string) {
        idx := strings.Index(str, sep)
        if idx < 0 {
                return str, ""
        }
        return str[:idx], str[idx+len(sep):]
}

func tryToSetValue

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/form_mapping.go:

func tryToSetValue(value reflect.Value, field reflect.StructField, setter setter, tag string) (bool, error) {
        var tagValue string
        var setOpt setOptions

        tagValue = field.Tag.Get(tag)
        tagValue, opts := head(tagValue, ",")

        if tagValue == "" { // default value is FieldName
                tagValue = field.Name
        }
        if tagValue == "" { // when field is "emptyField" variable
                return false, nil
        }

        var opt string
        for len(opts) > 0 {
                opt, opts = head(opts, ",")

                if k, v := head(opt, "="); k == "default" {
                        setOpt.isDefaultExists = true
                        setOpt.defaultValue = v
                }
        }

        return setter.TrySet(value, field, tagValue, setOpt)
}

func MultipartFormDataParser.Parse

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/multipart_formdata.go:

func (m *MultipartFormDataParser) Parse(src io.Reader, dst reflect.Value) (err error) {
        for dst.Kind() == reflect.Ptr {
                dst.Set(reflect.New(dst.Type().Elem()))
                dst = dst.Elem()
        }

        var (
                part   *multipart.Part
                body   []byte
                dt     = reflect.TypeOf(dst.Interface())
                reader = multipart.NewReader(src, m.boundary)
        )
        defer func() {
                if part != nil {
                        utils.CloseAnyway(part)
                }
        }()

        for {
                part, err = reader.NextPart()
                if err != nil {
                        if err == io.EOF {
                                err = nil
                        }
                        break
                }

                k := part.FormName()
                fNum := m.lookupFieldByTag(dt, k, "json")
                if fNum == -1 {
                        continue
                }
                fv := dst.Field(fNum)
                if !fv.IsValid() || !fv.CanSet() {
                        continue
                }

                // transform
                if body, err = ioutil.ReadAll(part); err != nil {
                        break
                } else if err = m.transformField(fv, body); err != nil {
                        break
                } else if err = part.Close(); err != nil {
                        break
                }
        }

        return
}

func ApplicationFormUrlencodedParser.Parse

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/application_x_www_form_urlencoded.go:

func (a *ApplicationFormUrlencodedParser) Parse(src io.Reader, dst reflect.Value) (err error) {
        body, err := io.ReadAll(src)
        if err != nil {
                return
        }

        vals, err := url.ParseQuery(string(body))
        if err != nil {
                return
        }

        return MapFormByTag(dst.Addr().Interface(), vals, "json")
}

func setByForm

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/form_mapping.go:

func setByForm(value reflect.Value, field reflect.StructField, form map[string][]string,
        tagValue string, opt setOptions) (isSetted bool, err error) {
        vs, ok := form[tagValue]
        if !ok && !opt.isDefaultExists {
                return false, nil
        }

        switch value.Kind() {
        case reflect.Slice:
                if !ok {
                        vs = []string{opt.defaultValue}
                }
                return true, setSlice(vs, value, field)
        case reflect.Array:
                if !ok {
                        vs = []string{opt.defaultValue}
                }
                if len(vs) != value.Len() {
                        return false, fmt.Errorf("%q is not valid value for %s", vs, value.Type().String())
                }
                return true, setArray(vs, value, field)
        default:
                var val string
                if !ok {
                        val = opt.defaultValue
                }

                if len(vs) > 0 {
                        val = vs[0]
                }
                return true, setWithProperType(val, value, field)
        }
}

func setFormMap

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/form_mapping.go:

func setFormMap(ptr any, form map[string][]string) error {
        switch ptrMap := ptr.(type) {
        case *map[string]any:
                *ptrMap = make(map[string]any, len(form))
                for k, v := range form {
                        (*ptrMap)[k] = v
                }
        case *[]map[string]any:
                *ptrMap = make([]map[string]any, 0, 1)
                tmp := make(map[string]any, len(form))
                for k, v := range form {
                        tmp[k] = v
                }
                *ptrMap = append(*ptrMap, tmp)
        case *map[string][]string:
                *ptrMap = make(map[string][]string, len(form))
                for k, v := range form {
                        (*ptrMap)[k] = v
                }
        case *map[string]string:
                *ptrMap = make(map[string]string, len(form))
                for k, v := range form {
                        (*ptrMap)[k] = v[len(v)-1] // pick last
                }
        default:
                return errors.New("cannot convert to map slices of strings")
        }

        return nil
}

func @48:8

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/multipart_formdata.go:

func() {
                if part != nil {
                        utils.CloseAnyway(part)
                }
        }

func setWithProperType

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/form_mapping.go:

func setWithProperType(val string, value reflect.Value, field reflect.StructField) error {
        switch value.Kind() {
        case reflect.Int:
                return setIntField(val, 0, value)
        case reflect.Int8:
                return setIntField(val, 8, value)
        case reflect.Int16:
                return setIntField(val, 16, value)
        case reflect.Int32:
                return setIntField(val, 32, value)
        case reflect.Int64:
                switch value.Interface().(type) {
                case time.Duration:
                        return setTimeDuration(val, value, field)
                }
                return setIntField(val, 64, value)
        case reflect.Uint:
                return setUintField(val, 0, value)
        case reflect.Uint8:
                return setUintField(val, 8, value)
        case reflect.Uint16:
                return setUintField(val, 16, value)
        case reflect.Uint32:
                return setUintField(val, 32, value)
        case reflect.Uint64:
                return setUintField(val, 64, value)
        case reflect.Bool:
                return setBoolField(val, value)
        case reflect.Float32:
                return setFloatField(val, 32, value)
        case reflect.Float64:
                return setFloatField(val, 64, value)
        case reflect.String:
                value.SetString(val)
        case reflect.Struct:
                switch value.Interface().(type) {
                case time.Time:
                        return setTimeField(val, field, value)
                }
                return json.Unmarshal(utils.UnsafeStringToBytes(val), value.Addr().Interface())
        case reflect.Map:
                return json.Unmarshal(utils.UnsafeStringToBytes(val), value.Addr().Interface())
        default:
                return errUnknownType
        }
        return nil
}

func setTimeField

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/form_mapping.go:

func setTimeField(val string, structField reflect.StructField, value reflect.Value) error {
        timeFormat := structField.Tag.Get("time_format")
        if timeFormat == "" {
                timeFormat = time.RFC3339
        }

        switch tf := strings.ToLower(timeFormat); tf {
        case "unix", "unixnano":
                tv, err := strconv.ParseInt(val, 10, 64)
                if err != nil {
                        return err
                }

                d := time.Duration(1)
                if tf == "unixnano" {
                        d = time.Second
                }

                t := time.Unix(tv/int64(d), tv%int64(d))
                value.Set(reflect.ValueOf(t))
                return nil

        }

        if val == "" {
                value.Set(reflect.ValueOf(time.Time{}))
                return nil
        }

        l := time.Local
        if isUTC, _ := strconv.ParseBool(structField.Tag.Get("time_utc")); isUTC {
                l = time.UTC
        }

        if locTag := structField.Tag.Get("time_location"); locTag != "" {
                loc, err := time.LoadLocation(locTag)
                if err != nil {
                        return err
                }
                l = loc
        }

        t, err := time.ParseInLocation(timeFormat, val, l)
        if err != nil {
                return err
        }

        value.Set(reflect.ValueOf(t))
        return nil
}

func setFloatField

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/form_mapping.go:

func setFloatField(val string, bitSize int, field reflect.Value) error {
        if val == "" {
                val = "0.0"
        }
        floatVal, err := strconv.ParseFloat(val, bitSize)
        if err == nil {
                field.SetFloat(floatVal)
        }
        return err
}

func setBoolField

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/form_mapping.go:

func setBoolField(val string, field reflect.Value) error {
        if val == "" {
                val = "false"
        }
        boolVal, err := strconv.ParseBool(val)
        if err == nil {
                field.SetBool(boolVal)
        }
        return err
}

func setUintField

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/form_mapping.go:

func setUintField(val string, bitSize int, field reflect.Value) error {
        if val == "" {
                val = "0"
        }
        uintVal, err := strconv.ParseUint(val, 10, bitSize)
        if err == nil {
                field.SetUint(uintVal)
        }
        return err
}

func setTimeDuration

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/form_mapping.go:

func setTimeDuration(val string, value reflect.Value, field reflect.StructField) error {
        d, err := time.ParseDuration(val)
        if err != nil {
                return err
        }
        value.Set(reflect.ValueOf(d))
        return nil
}

func @105:20

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/multipart_formdata.go:

105	`func(f reflect.Value, b []byte) (e error) { v, e := cast.ToInt64E(b); f.SetInt(v); return }`

func @100:20

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/multipart_formdata.go:

100	`func(f reflect.Value, b []byte) (e error) { v, e := cast.ToStringE(b); f.SetString(v); return }`

func @101:20

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/multipart_formdata.go:

101	`func(f reflect.Value, b []byte) (e error) { v, e := cast.ToInt64E(b); f.SetInt(v); return }`

func @102:20

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/multipart_formdata.go:

102	`func(f reflect.Value, b []byte) (e error) { v, e := cast.ToInt64E(b); f.SetInt(v); return }`

func @103:20

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/multipart_formdata.go:

103	`func(f reflect.Value, b []byte) (e error) { v, e := cast.ToInt64E(b); f.SetInt(v); return }`

func @104:20

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/multipart_formdata.go:

104	`func(f reflect.Value, b []byte) (e error) { v, e := cast.ToInt64E(b); f.SetInt(v); return }`

func @99:20

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/multipart_formdata.go:

99	`func(f reflect.Value, b []byte) (e error) { v, e := cast.ToBoolE(b); f.SetBool(v); return }`

func @106:20

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/multipart_formdata.go:

106	`func(f reflect.Value, b []byte) (e error) { v, e := cast.ToUint64E(b); f.SetUint(v); return }`

func @107:20

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/multipart_formdata.go:

107	`func(f reflect.Value, b []byte) (e error) { v, e := cast.ToUint64E(b); f.SetUint(v); return }`

func @108:20

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/multipart_formdata.go:

108	`func(f reflect.Value, b []byte) (e error) { v, e := cast.ToUint64E(b); f.SetUint(v); return }`

func @109:20

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/multipart_formdata.go:

109	`func(f reflect.Value, b []byte) (e error) { v, e := cast.ToUint64E(b); f.SetUint(v); return }`

func @110:20

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/multipart_formdata.go:

110	`func(f reflect.Value, b []byte) (e error) { v, e := cast.ToUint64E(b); f.SetUint(v); return }`

func ApplicationJsonParser.Parse

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/application_json.go:

func (a *ApplicationJsonParser) Parse(src io.Reader, dst reflect.Value) (err error) {
        if err = json.NewDecoder(src).Decode(dst.Addr().Interface()); err != nil {
                return malformedRequest(err.Error())
        }

        return
}

func @112:20

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/multipart_formdata.go:

112	`func(f reflect.Value, b []byte) (e error) { v, e := cast.ToFloat64E(b); f.SetFloat(v); return }`

func @111:20

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/multipart_formdata.go:

111	`func(f reflect.Value, b []byte) (e error) { v, e := cast.ToFloat64E(b); f.SetFloat(v); return }`

func ApplicationJsonParser.PreParse

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/application_json.go:

12	`func (a *ApplicationJsonParser) PreParse(args map[string]string) error {`
13	`return nil`
14	`}`

func malformedRequest

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/parser.go:

16	`func malformedRequest(msg string) error {`
17	`return fmt.Errorf("malformed request %s", msg)`
18	`}`

func unsupportedContentType

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/http/parser/parser.go:

20	`func unsupportedContentType(typ string) error {`
21	`return fmt.Errorf("unsupported content-type %s", typ)`
22	`}`

Package Overview: github.com/wfusion/gofusion/i18n 57.0%

Please select a function to see what's left for testing.

`bundle[T].AddMessages(...)`	`github.com/wfusion/gofusion/i18n/i18n.go`	`100.0%`	`9/9`
`NewBundle(...)`	`github.com/wfusion/gofusion/i18n/i18n.go`	`100.0%`	`6/6`
`DefaultLang(...)`	`github.com/wfusion/gofusion/i18n/construct.go`	`100.0%`	`4/4`
`@51:9(...)`	`github.com/wfusion/gofusion/i18n/construct.go`	`100.0%`	`3/3`
`AppName(...)`	`github.com/wfusion/gofusion/i18n/construct.go`	`100.0%`	`1/1`
`@66:9(...)`	`github.com/wfusion/gofusion/i18n/construct.go`	`100.0%`	`1/1`
`Var(...)`	`github.com/wfusion/gofusion/i18n/i18n.go`	`100.0%`	`1/1`
`init(...)`	`github.com/wfusion/gofusion/i18n/construct.go`	`100.0%`	`1/1`
`@57:9(...)`	`github.com/wfusion/gofusion/i18n/i18n.go`	`100.0%`	`1/1`
`Construct(...)`	`github.com/wfusion/gofusion/i18n/construct.go`	`95.0%`	`19/20`
`bundle[T].checkDuplicated(...)`	`github.com/wfusion/gofusion/i18n/i18n.go`	`27.3%`	`3/11`
`bundle[T].Localize(...)`	`github.com/wfusion/gofusion/i18n/i18n.go`	`0.0%`	`0/16`
`@142:9(...)`	`github.com/wfusion/gofusion/i18n/i18n.go`	`0.0%`	`0/3`
`@48:16(...)`	`github.com/wfusion/gofusion/i18n/construct.go`	`0.0%`	`0/1`
`@47:16(...)`	`github.com/wfusion/gofusion/i18n/construct.go`	`0.0%`	`0/1`
`Param(...)`	`github.com/wfusion/gofusion/i18n/i18n.go`	`0.0%`	`0/1`
`@130:9(...)`	`github.com/wfusion/gofusion/i18n/i18n.go`	`0.0%`	`0/1`
`Lang(...)`	`github.com/wfusion/gofusion/i18n/i18n.go`	`0.0%`	`0/1`
`@136:9(...)`	`github.com/wfusion/gofusion/i18n/i18n.go`	`0.0%`	`0/1`
`Langs(...)`	`github.com/wfusion/gofusion/i18n/i18n.go`	`0.0%`	`0/1`
`@124:9(...)`	`github.com/wfusion/gofusion/i18n/i18n.go`	`0.0%`	`0/1`
`Plural(...)`	`github.com/wfusion/gofusion/i18n/i18n.go`	`0.0%`	`0/1`

func bundle[T].AddMessages

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/i18n/i18n.go:

func (i *bundle[T]) AddMessages(code T, trans map[language.Tag]*Message, opts ...utils.OptionExtender) Localizable[T] {
        o := utils.ApplyOptions[addMessagesOption](opts...)

        i.mutex.Lock()
        defer i.mutex.Unlock()
        i.checkDuplicated(code, trans)

        id := cast.ToString(code)
        i.vars[code] = o.vars
        for lang, msg := range trans {
                i.bundle.MustAddMessages(lang, &i18n.Message{
                        ID:          id,
                        Hash:        msg.Hash,
                        Description: msg.Description,
                        LeftDelim:   msg.LeftDelim,
                        RightDelim:  msg.RightDelim,
                        Zero:        msg.Zero,
                        One:         msg.One,
                        Two:         msg.Two,
                        Few:         msg.Few,
                        Many:        msg.Many,
                        Other:       msg.Other,
                })
        }
        return i
}

func NewBundle

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/i18n/i18n.go:

func NewBundle[T comparable](lang language.Tag) Localizable[T] {
        b := &bundle[T]{
                dup:    utils.NewSet[T](),
                bundle: i18n.NewBundle(lang),
                vars:   make(map[T][]string),
        }

        b.bundle.RegisterUnmarshalFunc("json", json.Unmarshal)
        b.bundle.RegisterUnmarshalFunc("toml", toml.Unmarshal)
        b.bundle.RegisterUnmarshalFunc("yaml", yaml.Unmarshal)
        b.bundle.RegisterUnmarshalFunc("yml", yaml.Unmarshal)

        return b
}

func DefaultLang

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/i18n/construct.go:

func DefaultLang(opts ...utils.OptionExtender) (lang language.Tag) {
        opt := utils.ApplyOptions[useOption](opts...)

        conf := new(Conf)
        utils.MustSuccess(config.Use(opt.appName).LoadComponentConfig(config.ComponentI18n, conf))
        return utils.Must(language.Parse(conf.DefaultLang))
}

func @51:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/i18n/construct.go:

func() {
                locker.Lock()
                defer locker.Unlock()
                Bundle = &bundle[int]{
                        dup:    utils.NewSet[int](),
                        bundle: i18n.NewBundle(lang),
                }
        }

func AppName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/i18n/construct.go:

func AppName(name string) utils.OptionFunc[useOption] {
        return func(o *useOption) {
                o.appName = name
        }
}

func @66:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/i18n/construct.go:

66	`func(o *useOption) {`
67	`o.appName = name`
68	`}`

func Var

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/i18n/i18n.go:

func Var(vars ...string) utils.OptionFunc[addMessagesOption] {
        return func(o *addMessagesOption) {
                o.vars = vars
        }
}

func init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/i18n/construct.go:

79	`func init() {`
80	`config.AddComponent(config.ComponentI18n, Construct)`
81	`}`

func @57:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/i18n/i18n.go:

57	`func(o *addMessagesOption) {`
58	`o.vars = vars`
59	`}`

func Construct

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/i18n/construct.go:

func Construct(ctx context.Context, conf Conf, opts ...utils.OptionExtender) func() {
        var err error
        lang := defaultLang
        if utils.IsStrNotBlank(conf.DefaultLang) {
                if lang, err = language.Parse(conf.DefaultLang); err != nil {
                        panic(err)
                }
        }

        opt := utils.ApplyOptions[config.InitOption](opts...)
        optU := utils.ApplyOptions[useOption](opts...)
        if opt.AppName == "" {
                opt.AppName = optU.appName
        }

        locker.Lock()
        defer locker.Unlock()
        if Bundle == nil {
                Bundle = &bundle[int]{
                        dup:    utils.NewSet[int](),
                        bundle: i18n.NewBundle(lang),
                }
                Bundle.bundle.RegisterUnmarshalFunc("json", json.Unmarshal)
                Bundle.bundle.RegisterUnmarshalFunc("toml", toml.Unmarshal)
                Bundle.bundle.RegisterUnmarshalFunc("yaml", yaml.Unmarshal)
                Bundle.bundle.RegisterUnmarshalFunc("yml", yaml.Unmarshal)
        }

        // ioc
        if opt.DI != nil {
                opt.DI.
                        MustProvide(func() Localizable[int] { return NewBundle[int](lang) }).
                        MustProvide(func() Localizable[string] { return NewBundle[string](lang) })
        }

        return func() {
                locker.Lock()
                defer locker.Unlock()
                Bundle = &bundle[int]{
                        dup:    utils.NewSet[int](),
                        bundle: i18n.NewBundle(lang),
                }
        }
}

func bundle[T].checkDuplicated

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/i18n/i18n.go:

func (i *bundle[T]) checkDuplicated(code T, trans map[language.Tag]*Message) {
        if !i.dup.Contains(code) {
                i.dup.Insert(code)
                return
        }
        if trans == nil {
                panic(errors.Errorf("%+v %s code translation is empty", code, cast.ToString(code)))
        }

        // panic if duplicated
        var (
                cfg                = &i18n.LocalizeConfig{MessageID: cast.ToString(code)}
                existMsgEn         = i18n.NewLocalizer(i.bundle, language.English.String()).MustLocalize(cfg)
                existMsgCn         = i18n.NewLocalizer(i.bundle, language.Chinese.String()).MustLocalize(cfg)
                dupMsgCn, dupMsgEn string
        )
        if dupMsg, ok := trans[language.Chinese]; ok {
                dupMsgCn = dupMsg.Other
        }
        if dupMsg, ok := trans[language.English]; ok {
                dupMsgEn = dupMsg.Other
        }

        panic(errors.Errorf("%s(%s)(%+v)(%v) is duplicated with %s(%s)",
                dupMsgCn, dupMsgEn, code, cast.ToString(code), existMsgCn, existMsgEn))
}

func bundle[T].Localize

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/i18n/i18n.go:

func (i *bundle[T]) Localize(code T, opts ...utils.OptionExtender) (message string) {
        option := utils.ApplyOptions[localizeOption](opts...)
        if option.templateData == nil && len(i.vars) > 0 {
                option.templateData = make(map[string]any, len(i.vars))
        }

        // TODO: Access the third-party internationalization platform to obtain text
        cfg := &i18n.LocalizeConfig{
                MessageID:    cast.ToString(code),
                TemplateData: option.templateData,
                PluralCount:  option.pluralCount,
        }

        i.mutex.RLock()
        defer i.mutex.RUnlock()
        // Assign an empty string to a variable to avoid rendering < no value > data
        for _, v := range i.vars[code] {
                if _, ok := option.templateData[v]; !ok {
                        option.templateData[v] = ""
                }
        }
        message, err := i18n.NewLocalizer(i.bundle, option.langs...).Localize(cfg)
        if err == nil {
                return
        }
        message, ok := defaultErrorMessages[option.lang]
        if ok {
                return
        }

        return defaultErrorMessages[defaultLang]
}

func @142:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/i18n/i18n.go:

func(o *localizeOption) {
                if len(langs) > 0 {
                        o.lang, _ = language.Parse(langs[0])
                }
                o.langs = clone.SliceComparable(langs)
        }

func @48:16

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/i18n/construct.go:

48	`func() Localizable[string] { return NewBundle[string](lang) }`

func @47:16

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/i18n/construct.go:

47	`func() Localizable[int] { return NewBundle[int](lang) }`

func Param

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/i18n/i18n.go:

func Param(data map[string]any) utils.OptionFunc[localizeOption] {
        return func(o *localizeOption) {
                o.templateData = data
        }
}

func @130:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/i18n/i18n.go:

130	`func(o *localizeOption) {`
131	`o.pluralCount = pluralCount`
132	`}`

func Lang

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/i18n/i18n.go:

func Lang(lang language.Tag) utils.OptionFunc[localizeOption] {
        return func(o *localizeOption) {
                o.lang = lang
        }
}

func @136:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/i18n/i18n.go:

136	`func(o *localizeOption) {`
137	`o.lang = lang`
138	`}`

func Langs

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/i18n/i18n.go:

func Langs(langs []string) utils.OptionFunc[localizeOption] {
        return func(o *localizeOption) {
                if len(langs) > 0 {
                        o.lang, _ = language.Parse(langs[0])
                }
                o.langs = clone.SliceComparable(langs)
        }
}

func @124:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/i18n/i18n.go:

124	`func(o *localizeOption) {`
125	`o.templateData = data`
126	`}`

func Plural

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/i18n/i18n.go:

func Plural(pluralCount any) utils.OptionFunc[localizeOption] {
        return func(o *localizeOption) {
                o.pluralCount = pluralCount
        }
}

Package Overview: github.com/wfusion/gofusion/internal/configor 59.3%

Please select a function to see what's left for testing.

`Configor.GetErrorOnUnmatchedKeys(...)`	`github.com/wfusion/gofusion/internal/configor/configor.go`	`100.0%`	`1/1`
`Configor.Load(...)`	`github.com/wfusion/gofusion/internal/configor/configor.go`	`85.7%`	`6/7`
`@166:6(...)`	`github.com/wfusion/gofusion/internal/configor/configor.go`	`84.6%`	`11/13`
`Configor.load(...)`	`github.com/wfusion/gofusion/internal/configor/utils.go`	`82.4%`	`28/34`
`@96:13(...)`	`github.com/wfusion/gofusion/internal/configor/configor.go`	`77.8%`	`7/9`
`@316:11(...)`	`github.com/wfusion/gofusion/internal/configor/utils.go`	`75.0%`	`9/12`
`unmarshalJSON(...)`	`github.com/wfusion/gofusion/internal/configor/utils.go`	`75.0%`	`6/8`
`unmarshalToml(...)`	`github.com/wfusion/gofusion/internal/configor/utils.go`	`75.0%`	`3/4`
`Configor.GetEnvironment(...)`	`github.com/wfusion/gofusion/internal/configor/configor.go`	`71.4%`	`5/7`
`getPrefixForStruct(...)`	`github.com/wfusion/gofusion/internal/configor/utils.go`	`66.7%`	`2/3`
`Configor.getConfigurationFileWithENVPrefix(...)`	`github.com/wfusion/gofusion/internal/configor/utils.go`	`62.5%`	`5/8`
`Configor.getConfigurationFiles(...)`	`github.com/wfusion/gofusion/internal/configor/utils.go`	`61.3%`	`19/31`
`New(...)`	`github.com/wfusion/gofusion/internal/configor/configor.go`	`60.0%`	`9/15`
`Configor.getENVPrefix(...)`	`github.com/wfusion/gofusion/internal/configor/utils.go`	`60.0%`	`3/5`
`Configor.processTags(...)`	`github.com/wfusion/gofusion/internal/configor/utils.go`	`57.5%`	`23/40`
`Configor.processFile(...)`	`github.com/wfusion/gofusion/internal/configor/utils.go`	`27.3%`	`9/33`
`@345:8(...)`	`github.com/wfusion/gofusion/internal/configor/utils.go`	`25.0%`	`1/4`
`@114:18(...)`	`github.com/wfusion/gofusion/internal/configor/configor.go`	`0.0%`	`0/9`
`@145:14(...)`	`github.com/wfusion/gofusion/internal/configor/utils.go`	`0.0%`	`0/1`
`Load(...)`	`github.com/wfusion/gofusion/internal/configor/configor.go`	`0.0%`	`0/1`
`ENV(...)`	`github.com/wfusion/gofusion/internal/configor/configor.go`	`0.0%`	`0/1`
`@111:18(...)`	`github.com/wfusion/gofusion/internal/configor/configor.go`	`0.0%`	`0/1`
`UnmatchedTomlKeysError.Error(...)`	`github.com/wfusion/gofusion/internal/configor/utils.go`	`0.0%`	`0/1`

func Configor.GetErrorOnUnmatchedKeys

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/configor/configor.go:

153	`func (c *Configor) GetErrorOnUnmatchedKeys() bool {`
154	`return c.ErrorOnUnmatchedKeys`
155	`}`

func Configor.Load

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/configor/configor.go:

func (c *Configor) Load(config any, files ...string) (err error) {
        defaultValue := reflect.Indirect(reflect.ValueOf(config))
        if !defaultValue.CanAddr() {
                return fmt.Errorf("config %v should be addressable", config)
        }
        err, _ = c.load(config, false, files...)

        if c.Config.AutoReload {
                go func() {
                        timer := time.NewTimer(c.Config.AutoReloadInterval)
                        for range timer.C {
                                reflectPtr := reflect.New(reflect.ValueOf(config).Elem().Type())
                                reflectPtr.Elem().Set(defaultValue)

                                var changed bool
                                if err, changed = c.load(reflectPtr.Interface(), true, files...); err == nil && changed {
                                        reflect.ValueOf(config).Elem().Set(reflectPtr.Elem())
                                        if c.Config.AutoReloadCallback != nil {
                                                c.Config.AutoReloadCallback(config)
                                        }
                                } else if err != nil {
                                        if !c.Silent {
                                                fmt.Printf("Failed to reload configuration from %v, got error %v\n", files, err)
                                        }
                                }
                                timer.Reset(c.Config.AutoReloadInterval)
                        }
                }()
        }
        return
}

func @166:6

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/configor/configor.go:

func() {
                        timer := time.NewTimer(c.Config.AutoReloadInterval)
                        for range timer.C {
                                reflectPtr := reflect.New(reflect.ValueOf(config).Elem().Type())
                                reflectPtr.Elem().Set(defaultValue)

                                var changed bool
                                if err, changed = c.load(reflectPtr.Interface(), true, files...); err == nil && changed {
                                        reflect.ValueOf(config).Elem().Set(reflectPtr.Elem())
                                        if c.Config.AutoReloadCallback != nil {
                                                c.Config.AutoReloadCallback(config)
                                        }
                                } else if err != nil {
                                        if !c.Silent {
                                                fmt.Printf("Failed to reload configuration from %v, got error %v\n", files, err)
                                        }
                                }
                                timer.Reset(c.Config.AutoReloadInterval)
                        }
                }

func Configor.load

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/configor/utils.go:

func (c *Configor) load(config any, watchMode bool, files ...string) (err error, changed bool) {
        defer func() {
                if c.Config.Debug || c.Config.Verbose {
                        if err != nil {
                                fmt.Printf("Failed to load configuration from %v, got %v\n", files, err)
                        }

                        fmt.Printf("Configuration:\n  %#v\n", config)
                }
        }()

        configFiles, configModTimeMap, hashMap := c.getConfigurationFiles(c.Config, watchMode, files...)
        if watchMode && len(configModTimeMap) == len(c.configModTimes) && len(hashMap) == len(c.configHash) {
                var changed bool
                for f, curModTime := range configModTimeMap {
                        curHash := hashMap[f]
                        preHash, ok1 := c.configHash[f]
                        preModTime, ok2 := c.configModTimes[f]
                        if changed = !ok1 || !ok2 || curModTime.After(preModTime) || curHash != preHash; changed {
                                break
                        }
                }

                if !changed {
                        return nil, false
                }
        }

        type withCallback interface {
                BeforeLoad(any)
                AfterLoad(any)
        }
        if cb, ok := config.(withCallback); ok {
                cb.BeforeLoad(config)
                defer cb.AfterLoad(config)
        }

        for _, file := range configFiles {
                if c.Config.Debug || c.Config.Verbose {
                        fmt.Printf("Loading configurations from file '%v'...\n", file)
                }
                if err = c.processFile(config, file, c.GetErrorOnUnmatchedKeys()); err != nil {
                        return err, true
                }
        }

        // process defaults after process file because map struct should be assigned first
        _ = utils.ParseTag(config, utils.ParseTagName("default"), utils.ParseTagUnmarshalType(utils.UnmarshalTypeYaml))

        // process file again to ensure read config from file
        for _, file := range configFiles {
                if c.Config.Debug || c.Config.Verbose {
                        fmt.Printf("Loading configurations from file '%v'...\n", file)
                }
                if err = c.processFile(config, file, c.GetErrorOnUnmatchedKeys()); err != nil {
                        return err, true
                }
        }

        c.configHash = hashMap
        c.configModTimes = configModTimeMap

        if prefix := c.getENVPrefix(config); prefix == "-" {
                err = c.processTags(config)
        } else {
                err = c.processTags(config, prefix)
        }

        // process defaults
        _ = utils.ParseTag(config, utils.ParseTagName("default"), utils.ParseTagUnmarshalType(utils.UnmarshalTypeYaml))

        return err, true
}

func @96:13

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/configor/configor.go:

func(name string) (h string, err error) {
                        var file fs.File
                        if file, err = os.Open(name); err != nil {
                                return
                        }
                        defer utils.CloseAnyway(file)
                        sha256Hash := sha256.New()
                        if _, err = io.Copy(sha256Hash, file); err != nil {
                                return
                        }
                        h = string(sha256Hash.Sum(nil))
                        return
                }

func @316:11

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/configor/utils.go:

func(field reflect.Value, fieldStruct reflect.StructField) {
                                        if !configValue.IsZero() {
                                                // load slice from env
                                                newVal := reflect.New(field.Type().Elem()).Elem()
                                                if newVal.Kind() == reflect.Struct {
                                                        idx := 0
                                                        for {
                                                                newVal = reflect.New(field.Type().Elem()).Elem()
                                                                if err := c.processTags(newVal.Addr().Interface(), append(
                                                                        getPrefixForStruct(prefixes, &fieldStruct), fmt.Sprint(idx))...); err != nil {
                                                                        return // err
                                                                } else if reflect.DeepEqual(newVal.Interface(),
                                                                        reflect.New(field.Type().Elem()).Elem().Interface()) {
                                                                        break
                                                                } else {
                                                                        idx++
                                                                        field.Set(reflect.Append(field, newVal))
                                                                }
                                                        }
                                                }
                                        }
                                }

func unmarshalJSON

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/configor/utils.go:

func unmarshalJSON(data []byte, config any, errorOnUnmatchedKeys bool) error {
        reader := strings.NewReader(string(data))
        decoder := json.NewDecoder(reader)

        if errorOnUnmatchedKeys {
                decoder.DisallowUnknownFields()
        }

        err := decoder.Decode(config)
        if err != nil && err != io.EOF {
                return err
        }
        return nil
}

func unmarshalToml

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/configor/utils.go:

func unmarshalToml(data []byte, config any, errorOnUnmatchedKeys bool) error {
        metadata, err := toml.Decode(string(data), config)
        if err == nil && len(metadata.Undecoded()) > 0 && errorOnUnmatchedKeys {
                return &UnmatchedTomlKeysError{Keys: metadata.Undecoded()}
        }
        return err
}

func Configor.GetEnvironment

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/configor/configor.go:

func (c *Configor) GetEnvironment() string {
        if c.Environment == "" {
                if env := os.Getenv("CONFIGOR_ENV"); env != "" {
                        return env
                }

                if testRegexp.MatchString(os.Args[0]) {
                        return "test"
                }

                return "development"
        }
        return c.Environment
}

func getPrefixForStruct

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/configor/utils.go:

func getPrefixForStruct(prefixes []string, fieldStruct *reflect.StructField) []string {
        if fieldStruct.Anonymous && fieldStruct.Tag.Get("anonymous") == "true" {
                return prefixes
        }
        return append(prefixes, fieldStruct.Name)
}

func Configor.getConfigurationFileWithENVPrefix

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/configor/utils.go:

func (c *Configor) getConfigurationFileWithENVPrefix(file, env string) (string, time.Time, string, error) {
        var (
                envFile string
                extname = path.Ext(file)
        )

        if extname == "" {
                envFile = fmt.Sprintf("%v.%v", file, env)
        } else {
                envFile = fmt.Sprintf("%v.%v%v", strings.TrimSuffix(file, extname), env, extname)
        }

        if fileInfo, err := c.statFunc(envFile); err == nil && fileInfo.Mode().IsRegular() {
                fileHash, _ := c.hashFunc(envFile)
                return envFile, fileInfo.ModTime(), fileHash, nil
        }
        return "", time.Now(), "", fmt.Errorf("failed to find file %v", file)
}

func Configor.getConfigurationFiles

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/configor/utils.go:

func (c *Configor) getConfigurationFiles(config *Config, watchMode bool, files ...string) (
        []string, map[string]time.Time, map[string]string) {
        resultKeys := make([]string, 0, len(files))
        hashResult := make(map[string]string, len(files))
        modTimeResult := make(map[string]time.Time, len(files))
        if !watchMode && (c.Config.Debug || c.Config.Verbose) {
                fmt.Printf("Current environment: '%v'\n", c.GetEnvironment())
        }

        for i := len(files) - 1; i >= 0; i-- {
                foundFile := false
                file := files[i]

                // check configuration
                if fileInfo, err := c.statFunc(file); err == nil && fileInfo.Mode().IsRegular() {
                        foundFile = true
                        resultKeys = append(resultKeys, file)
                        modTimeResult[file] = fileInfo.ModTime()
                        if hash, err := c.hashFunc(file); err == nil {
                                hashResult[file] = hash
                        }
                }

                // check configuration with env
                if file, modTime, hash, err := c.getConfigurationFileWithENVPrefix(file, c.GetEnvironment()); err == nil {
                        foundFile = true
                        resultKeys = append(resultKeys, file)
                        modTimeResult[file] = modTime
                        if hash != "" {
                                hashResult[file] = hash
                        }
                }

                // check example configuration
                if !foundFile {
                        if example, modTime, hash, err := c.getConfigurationFileWithENVPrefix(file, "example"); err == nil {
                                if !watchMode && !c.Silent {
                                        log.Printf("Failed to find configuration %v, using example file %v\n", file, example)
                                }
                                resultKeys = append(resultKeys, example)
                                modTimeResult[example] = modTime
                                if hash != "" {
                                        hashResult[file] = hash
                                }
                        } else if !c.Silent {
                                fmt.Printf("Failed to find configuration %v\n", file)
                        }
                }
        }
        return resultKeys, modTimeResult, hashResult
}

func New

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/configor/configor.go:

func New(config *Config) *Configor {
        if config == nil {
                config = &Config{}
        }

        if os.Getenv("CONFIGOR_DEBUG_MODE") != "" {
                config.Debug = true
        }

        if os.Getenv("CONFIGOR_VERBOSE_MODE") != "" {
                config.Verbose = true
        }

        if os.Getenv("CONFIGOR_SILENT_MODE") != "" {
                config.Silent = true
        }

        if config.AutoReload && config.AutoReloadInterval == 0 {
                config.AutoReloadInterval = time.Second
        }

        cfg := &Configor{
                Config:         config,
                configHash:     make(map[string]string),
                configModTimes: make(map[string]time.Time),
                statFunc:       os.Stat,
                hashFunc: func(name string) (h string, err error) {
                        var file fs.File
                        if file, err = os.Open(name); err != nil {
                                return
                        }
                        defer utils.CloseAnyway(file)
                        sha256Hash := sha256.New()
                        if _, err = io.Copy(sha256Hash, file); err != nil {
                                return
                        }
                        h = string(sha256Hash.Sum(nil))
                        return
                },
        }
        if cfg.FS != nil {
                cfg.statFunc = func(name string) (os.FileInfo, error) {
                        return fs.Stat(cfg.FS, name)
                }
                cfg.hashFunc = func(name string) (h string, err error) {
                        var file fs.File
                        if file, err = cfg.FS.Open(name); err != nil {
                                return
                        }
                        defer utils.CloseAnyway(file)
                        sha256Hash := sha256.New()
                        if _, err = io.Copy(sha256Hash, file); err != nil {
                                return
                        }
                        h = string(sha256Hash.Sum(nil))
                        return
                }
        }

        return cfg
}

func Configor.getENVPrefix

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/configor/utils.go:

func (c *Configor) getENVPrefix(config any) string {
        if c.Config.ENVPrefix == "" {
                if prefix := os.Getenv("CONFIGOR_ENV_PREFIX"); prefix != "" {
                        return prefix
                }
                return "Configor"
        }
        return c.Config.ENVPrefix
}

func Configor.processTags

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/configor/utils.go:

func (c *Configor) processTags(config any, prefixes ...string) error {
        configValue := reflect.Indirect(reflect.ValueOf(config))
        if configValue.Kind() != reflect.Struct {
                return errors.New("invalid config, should be struct")
        }

        configType := configValue.Type()
        for i := 0; i < configType.NumField(); i++ {
                var (
                        envNames    []string
                        fieldStruct = configType.Field(i)
                        field       = configValue.Field(i)
                        envName     = fieldStruct.Tag.Get("env") // read configuration from shell env
                )

                if !field.CanAddr() || !field.CanInterface() {
                        continue
                }

                if envName == "" {
                        envNames = append(envNames,
                                strings.Join(append(prefixes, fieldStruct.Name), "_")) // Configor_DB_Name
                        envNames = append(envNames,
                                strings.ToUpper(strings.Join(append(prefixes, fieldStruct.Name), "_"))) // CONFIGOR_DB_NAME
                } else {
                        envNames = []string{envName}
                }

                if c.Config.Verbose {
                        fmt.Printf("Trying to load struct `%v`'s field `%v` from env %v\n",
                                configType.Name(), fieldStruct.Name, strings.Join(envNames, ", "))
                }

                // Load From Shell ENV
                for _, env := range envNames {
                        if value := os.Getenv(env); value != "" {
                                if c.Config.Debug || c.Config.Verbose {
                                        fmt.Printf("Loading configuration for struct `%v`'s field `%v` from env %v...\n",
                                                configType.Name(), fieldStruct.Name, env)
                                }

                                switch reflect.Indirect(field).Kind() {
                                case reflect.Bool:
                                        switch strings.ToLower(value) {
                                        case "", "0", "f", "false":
                                                field.Set(reflect.ValueOf(false))
                                        default:
                                                field.Set(reflect.ValueOf(true))
                                        }
                                case reflect.String:
                                        field.Set(reflect.ValueOf(value))
                                default:
                                        if err := yaml.Unmarshal([]byte(value), field.Addr().Interface()); err != nil {
                                                return err
                                        }
                                }
                                break
                        }
                }

                if isBlank := reflect.DeepEqual(field.Interface(), reflect.Zero(field.Type()).Interface()); isBlank &&
                        fieldStruct.Tag.Get("required") == "true" {
                        // return error if it is required but blank
                        return errors.New(fieldStruct.Name + " is required, but blank")
                }

                field = utils.IndirectValue(field)
                if field.Kind() == reflect.Struct {
                        if err := c.processTags(field.Addr().Interface(),
                                getPrefixForStruct(prefixes, &fieldStruct)...); err != nil {
                                return err
                        }
                }

                if field.Kind() == reflect.Slice {
                        if arrLen := field.Len(); arrLen > 0 {
                                for i := 0; i < arrLen; i++ {
                                        if reflect.Indirect(field.Index(i)).Kind() == reflect.Struct {
                                                if err := c.processTags(field.Index(i).Addr().Interface(),
                                                        append(getPrefixForStruct(prefixes, &fieldStruct), fmt.Sprint(i))...); err != nil {
                                                        return err
                                                }
                                        }
                                }
                        } else {
                                defer func(field reflect.Value, fieldStruct reflect.StructField) {
                                        if !configValue.IsZero() {
                                                // load slice from env
                                                newVal := reflect.New(field.Type().Elem()).Elem()
                                                if newVal.Kind() == reflect.Struct {
                                                        idx := 0
                                                        for {
                                                                newVal = reflect.New(field.Type().Elem()).Elem()
                                                                if err := c.processTags(newVal.Addr().Interface(), append(
                                                                        getPrefixForStruct(prefixes, &fieldStruct), fmt.Sprint(idx))...); err != nil {
                                                                        return // err
                                                                } else if reflect.DeepEqual(newVal.Interface(),
                                                                        reflect.New(field.Type().Elem()).Elem().Interface()) {
                                                                        break
                                                                } else {
                                                                        idx++
                                                                        field.Set(reflect.Append(field, newVal))
                                                                }
                                                        }
                                                }
                                        }
                                }(field, fieldStruct)
                        }
                }
        }
        return nil
}

func Configor.processFile

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/configor/utils.go:

func (c *Configor) processFile(config any, file string, errorOnUnmatchedKeys bool) error {
        readFile := ioutil.ReadFile
        if c.FS != nil {
                readFile = func(filename string) ([]byte, error) {
                        return fs.ReadFile(c.FS, filename)
                }
        }
        data, err := readFile(file)
        if err != nil {
                return err
        }

        switch {
        case strings.HasSuffix(file, ".yaml") || strings.HasSuffix(file, ".yml"):
                if errorOnUnmatchedKeys {
                        decoder := yaml.NewDecoder(bytes.NewBuffer(data))
                        decoder.KnownFields(true)
                        return decoder.Decode(config)
                }
                return yaml.Unmarshal(data, config)
        case strings.HasSuffix(file, ".toml"):
                return unmarshalToml(data, config, errorOnUnmatchedKeys)
        case strings.HasSuffix(file, ".json"):
                return unmarshalJSON(data, config, errorOnUnmatchedKeys)
        default:
                if err := unmarshalToml(data, config, errorOnUnmatchedKeys); err == nil {
                        return nil
                } else if errUnmatchedKeys, ok := err.(*UnmatchedTomlKeysError); ok {
                        return errUnmatchedKeys
                }

                if err := unmarshalJSON(data, config, errorOnUnmatchedKeys); err == nil {
                        return nil
                } else if strings.Contains(err.Error(), "json: unknown field") {
                        return err
                }

                var yamlError error
                if errorOnUnmatchedKeys {
                        decoder := yaml.NewDecoder(bytes.NewBuffer(data))
                        decoder.KnownFields(true)
                        yamlError = decoder.Decode(config)
                } else {
                        yamlError = yaml.Unmarshal(data, config)
                }

                if yamlError == nil {
                        return nil
                } else if yErr, ok := yamlError.(*yaml.TypeError); ok {
                        return yErr
                }

                return errors.New("failed to decode config")
        }
}

func @345:8

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/configor/utils.go:

func() {
                if c.Config.Debug || c.Config.Verbose {
                        if err != nil {
                                fmt.Printf("Failed to load configuration from %v, got %v\n", files, err)
                        }

                        fmt.Printf("Configuration:\n  %#v\n", config)
                }
        }

func @114:18

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/configor/configor.go:

func(name string) (h string, err error) {
                        var file fs.File
                        if file, err = cfg.FS.Open(name); err != nil {
                                return
                        }
                        defer utils.CloseAnyway(file)
                        sha256Hash := sha256.New()
                        if _, err = io.Copy(sha256Hash, file); err != nil {
                                return
                        }
                        h = string(sha256Hash.Sum(nil))
                        return
                }

func @145:14

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/configor/utils.go:

145	`func(filename string) ([]byte, error) {`
146	`return fs.ReadFile(c.FS, filename)`
147	`}`

func Load

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/configor/configor.go:

196	`func Load(config any, files ...string) error {`
197	`return New(nil).Load(config, files...)`
198	`}`

func ENV

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/configor/configor.go:

191	`func ENV() string {`
192	`return New(nil).GetEnvironment()`
193	`}`

func @111:18

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/configor/configor.go:

111	`func(name string) (os.FileInfo, error) {`
112	`return fs.Stat(cfg.FS, name)`
113	`}`

func UnmatchedTomlKeysError.Error

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/configor/utils.go:

57	`func (e *UnmatchedTomlKeysError) Error() string {`
58	`return fmt.Sprintf("There are keys in the config file that do not match any field in the given struct: %v", e.Keys)`
59	`}`

Package Overview: github.com/wfusion/gofusion/internal/util/payload 60.2%

Please select a function to see what's left for testing.

`@41:9(...)`	`github.com/wfusion/gofusion/internal/util/payload/types.go`	`100.0%`	`1/1`
`Context(...)`	`github.com/wfusion/gofusion/internal/util/payload/types.go`	`100.0%`	`1/1`
`@29:9(...)`	`github.com/wfusion/gofusion/internal/util/payload/types.go`	`100.0%`	`1/1`
`Serialize(...)`	`github.com/wfusion/gofusion/internal/util/payload/types.go`	`100.0%`	`1/1`
`@35:9(...)`	`github.com/wfusion/gofusion/internal/util/payload/types.go`	`100.0%`	`1/1`
`Compress(...)`	`github.com/wfusion/gofusion/internal/util/payload/types.go`	`100.0%`	`1/1`
`Type(...)`	`github.com/wfusion/gofusion/internal/util/payload/types.go`	`100.0%`	`1/1`
`@47:9(...)`	`github.com/wfusion/gofusion/internal/util/payload/types.go`	`100.0%`	`1/1`
`unsealV1(...)`	`github.com/wfusion/gofusion/internal/util/payload/unseal.go`	`85.4%`	`35/41`
`unsealV1T(...)`	`github.com/wfusion/gofusion/internal/util/payload/unseal.go`	`75.6%`	`31/41`
`Seal(...)`	`github.com/wfusion/gofusion/internal/util/payload/seal.go`	`69.8%`	`37/53`
`Unseal(...)`	`github.com/wfusion/gofusion/internal/util/payload/unseal.go`	`66.7%`	`6/9`
`UnsealT(...)`	`github.com/wfusion/gofusion/internal/util/payload/unseal.go`	`66.7%`	`6/9`
`UnsealRaw(...)`	`github.com/wfusion/gofusion/internal/util/payload/unseal.go`	`40.0%`	`4/10`
`unsealRawV1(...)`	`github.com/wfusion/gofusion/internal/util/payload/unseal.go`	`0.0%`	`0/22`
`defaultUnseal(...)`	`github.com/wfusion/gofusion/internal/util/payload/unseal.go`	`0.0%`	`0/16`
`@53:9(...)`	`github.com/wfusion/gofusion/internal/util/payload/types.go`	`0.0%`	`0/1`
`Version(...)`	`github.com/wfusion/gofusion/internal/util/payload/types.go`	`0.0%`	`0/1`

func @41:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/util/payload/types.go:

41	`func(o *option) {`
42	`o.compressType = compressType`
43	`}`

func Context

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/util/payload/types.go:

func Context(ctx context.Context) utils.OptionFunc[option] {
        return func(o *option) {
                o.ctx = ctx
        }
}

func @29:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/util/payload/types.go:

29	`func(o *option) {`
30	`o.ctx = ctx`
31	`}`

func Serialize

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/util/payload/types.go:

func Serialize(serializeType serialize.Algorithm) utils.OptionFunc[option] {
        return func(o *option) {
                o.serializeType = serializeType
        }
}

func @35:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/util/payload/types.go:

35	`func(o *option) {`
36	`o.serializeType = serializeType`
37	`}`

func Compress

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/util/payload/types.go:

func Compress(compressType compress.Algorithm) utils.OptionFunc[option] {
        return func(o *option) {
                o.compressType = compressType
        }
}

func Type

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/util/payload/types.go:

func Type(typ reflect.Type) utils.OptionFunc[option] {
        return func(o *option) {
                o.dataType = typ
        }
}

func @47:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/util/payload/types.go:

47	`func(o *option) {`
48	`o.dataType = typ`
49	`}`

func unsealV1

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/util/payload/unseal.go:

func unsealV1(inf, src []byte, opts ...utils.OptionExtender) (ctx context.Context, dst any, ok bool, err error) {
        opt := utils.ApplyOptions[option](opts...)
        serializeType := serialize.ParseAlgorithm(serialize.Algorithm(inf[1]))
        if opt.serializeType.IsValid() {
                serializeType = opt.serializeType
        }
        compressType := compress.ParseAlgorithm(compress.Algorithm(inf[2]))
        if opt.compressType.IsValid() {
                compressType = opt.compressType
        }

        isRaw := false
        if inf[3] == 1 {
                isRaw = true
        }

        // unseal encrypted inf
        encryptedInfLength := binary.LittleEndian.Uint32(inf[4:])
        _, src = src[:encryptedInfLength], src[encryptedInfLength:]

        // unseal context
        contextLengthBytes, src := src[:8], src[8:]
        contextLength := binary.LittleEndian.Uint64(contextLengthBytes)
        if contextLength > 0 {
                var contextBytes []byte
                contextBytes, src = src[:contextLength], src[contextLength:]
                ctx = fusCtx.New(fusCtx.Context(contextBytes))
        }

        // unseal data type
        inf, src = src[:8], src[8:]
        structNameLength := binary.LittleEndian.Uint64(inf)
        structName, src := src[:structNameLength], src[structNameLength:]
        if !isRaw && opt.dataType == nil {
                if opt.dataType = inspect.TypeOf(string(structName)); opt.dataType == nil {
                        opt.dataType = reflect.TypeOf((*any)(nil)).Elem()
                }
        }

        // unseal data
        // unseal data length
        _, src = src[:8], src[8:]
        // binary.LittleEndian.Uint64(src[:8])

        // unseal data
        var decoded []byte
        if compressType.IsValid() {
                decoded, err = encode.From(src).Decode(encode.Compress(compressType)).ToBytes()
        } else {
                decoded = src
        }
        if err != nil {
                return
        }

        if !serializeType.IsValid() {
                dst = decoded
        } else {
                dstBuffer, cb := utils.BytesBufferPool.Get(nil)
                defer cb()
                dstBuffer.Write(decoded)

                unmarshalFunc := serialize.UnmarshalStreamFuncByType(serializeType, opt.dataType)
                if dst, err = unmarshalFunc(dstBuffer); err != nil {
                        return
                }
        }

        ok = true
        return
}

func unsealV1T

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/util/payload/unseal.go:

func unsealV1T[T any](inf, src []byte, opts ...utils.OptionExtender) (ctx context.Context, dst T, ok bool, err error) {
        opt := utils.ApplyOptions[option](opts...)
        serializeType := serialize.ParseAlgorithm(serialize.Algorithm(inf[1]))
        if opt.serializeType.IsValid() {
                serializeType = opt.serializeType
        }
        compressType := compress.ParseAlgorithm(compress.Algorithm(inf[2]))
        if opt.compressType.IsValid() {
                compressType = opt.compressType
        }

        isRaw := false
        if inf[3] == 1 {
                isRaw = true
        }

        // unseal encrypted inf
        encryptedInfLength := binary.LittleEndian.Uint32(inf[4:])
        _, src = src[:encryptedInfLength], src[encryptedInfLength:]

        // unseal context
        contextLengthBytes, src := src[:8], src[8:]
        contextLength := binary.LittleEndian.Uint64(contextLengthBytes)
        if contextLength > 0 {
                var contextBytes []byte
                contextBytes, src = src[:contextLength], src[contextLength:]
                ctx = fusCtx.New(fusCtx.Context(contextBytes))
        }

        // unseal data type
        inf, src = src[:8], src[8:]
        structNameLength := binary.LittleEndian.Uint64(inf)
        structName, src := src[:structNameLength], src[structNameLength:]
        if !isRaw && opt.dataType == nil {
                if opt.dataType = inspect.TypeOf(string(structName)); opt.dataType == nil {
                        opt.dataType = reflect.TypeOf((*any)(nil)).Elem()
                }
        }

        // unseal data
        // unseal data length
        _, src = src[:8], src[8:]
        // binary.LittleEndian.Uint64(src[:8])

        // unseal data
        var decoded []byte
        if compressType.IsValid() {
                decoded, err = encode.From(src).Decode(encode.Compress(compressType)).ToBytes()
        } else {
                decoded = src
        }
        if err != nil {
                return
        }

        if !serializeType.IsValid() {
                dst = reflect.ValueOf(decoded).Convert(reflect.TypeOf(new(T)).Elem()).Interface().(T)
        } else {
                dstBuffer, cb := utils.BytesBufferPool.Get(nil)
                defer cb()
                dstBuffer.Write(decoded)

                unmarshalFunc := serialize.UnmarshalStreamFunc[T](serializeType)
                if dst, err = unmarshalFunc(dstBuffer); err != nil {
                        return
                }
        }

        ok = true
        return
}

func Seal

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/util/payload/seal.go:

func Seal(data any, opts ...utils.OptionExtender) (dst []byte, err error) {
        opt := utils.ApplyOptions[option](opts...)

        dstBuffer, cb := utils.BytesBufferPool.Get(nil)
        defer cb()

        dbytes, ok1 := data.([]byte)
        dstring, ok2 := data.(string)
        isRaw := ok1 || ok2

        // magic number
        if err = binary.Write(dstBuffer, binary.LittleEndian, sealMagicNumber); err != nil {
                return
        }

        // seal info
        inf := sealTypeNumber
        if opt.version > 0 {
                inf[0] = opt.version
        }
        if isRaw {
                inf[3] = 1
        } else {
                inf[1] = opt.serializeType.Value()
        }
        inf[2] = opt.compressType.Value()
        if err = binary.Write(dstBuffer, binary.LittleEndian, inf[:]); err != nil {
                return
        }

        // seal encrypted info TODO

        // seal context
        if opt.ctx == nil {
                if err = binary.Write(dstBuffer, binary.LittleEndian, uint64(0)); err != nil {
                        return
                }
        } else {
                ctxBytes := fusCtx.Flatten(opt.ctx).Marshal()
                if err = binary.Write(dstBuffer, binary.LittleEndian, uint64(len(ctxBytes))); err != nil {
                        return
                }
                if err = binary.Write(dstBuffer, binary.LittleEndian, ctxBytes); err != nil {
                        return
                }
        }

        // seal data type
        dt := utils.IndirectValue(reflect.ValueOf(data)).Type()
        structName := dt.PkgPath() + "." + dt.Name()
        if err = binary.Write(dstBuffer, binary.LittleEndian, uint64(len(structName))); err != nil {
                return
        }
        if err = binary.Write(dstBuffer, binary.LittleEndian, []byte(structName)); err != nil {
                return
        }

        // seal data
        marshaledBuffer, cb := utils.BytesBufferPool.Get(nil)
        defer cb()

        if isRaw {
                switch {
                case ok1:
                        marshaledBuffer.Write(dbytes)
                case ok2:
                        marshaledBuffer.WriteString(dstring)
                }
        } else {
                marshalFunc := serialize.MarshalStreamFunc(opt.serializeType, serialize.JsonEscapeHTML(false))
                if err = marshalFunc(marshaledBuffer, data); err != nil {
                        return
                }
        }

        var encoded []byte
        if opt.compressType.IsValid() {
                encoded, err = encode.From(marshaledBuffer.Bytes()).Encode(encode.Compress(opt.compressType)).ToBytes()
        } else {
                encoded = marshaledBuffer.Bytes()
        }
        if err != nil {
                return
        }

        if err = binary.Write(dstBuffer, binary.LittleEndian, uint64(len(encoded))); err != nil {
                return
        }
        if err = binary.Write(dstBuffer, binary.LittleEndian, encoded); err != nil {
                return
        }

        dst = make([]byte, dstBuffer.Len())
        copy(dst, dstBuffer.Bytes())
        return
}

func Unseal

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/util/payload/unseal.go:

func Unseal(src []byte, opts ...utils.OptionExtender) (ctx context.Context, dst any, ok bool, err error) {
        if len(src) <= sealPrefixLength {
                return defaultUnseal(src, opts...)
        }

        // unseal magic number
        magicNumber, next := src[:4], src[4:]
        if binary.LittleEndian.Uint32(magicNumber) != sealMagicNumber {
                return defaultUnseal(src, opts...)
        }

        // unseal info
        inf, next := next[:len(sealTypeNumber)], next[len(sealTypeNumber):]
        switch inf[0] {
        case 1:
                return unsealV1(inf, next, opts...)
        default:
                panic(errors.Errorf("unsupported message version for unseal: %v", inf[0]))
        }
}

func UnsealT

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/util/payload/unseal.go:

func UnsealT[T any](src []byte, opts ...utils.OptionExtender) (ctx context.Context, dst T, ok bool, err error) {
        if len(src) <= sealPrefixLength {
                return
        }

        // unseal magic number
        magicNumber, src := src[:4], src[4:]
        if binary.LittleEndian.Uint32(magicNumber) != sealMagicNumber {
                return
        }

        // unseal info
        inf, src := src[:len(sealTypeNumber)], src[len(sealTypeNumber):]
        switch inf[0] {
        case 1:
                return unsealV1T[T](inf, src, opts...)
        default:
                panic(errors.Errorf("unsupported message version for unseal: %v", inf[0]))
        }
}

func UnsealRaw

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/util/payload/unseal.go:

func UnsealRaw(src []byte, opts ...utils.OptionExtender) (ctx context.Context, dst []byte, isRaw bool, err error) {
        if len(src) <= sealPrefixLength {
                return nil, src, true, nil
        }

        // unseal magic number
        magicNumber, next := src[:4], src[4:]
        if binary.LittleEndian.Uint32(magicNumber) != sealMagicNumber {
                return nil, src, true, nil
        }

        // unseal info
        inf, src := next[:len(sealTypeNumber)], next[len(sealTypeNumber):]
        switch inf[0] {
        case 1:
                return unsealRawV1(inf, src, opts...)
        default:
                panic(errors.Errorf("unsupported message version for unseal raw: %v", inf[0]))
        }
        return
}

func unsealRawV1

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/util/payload/unseal.go:

func unsealRawV1(inf, src []byte, opts ...utils.OptionExtender) (
        ctx context.Context, dst []byte, isRaw bool, err error) {
        opt := utils.ApplyOptions[option](opts...)
        compressType := compress.ParseAlgorithm(compress.Algorithm(inf[2]))
        if opt.compressType.IsValid() {
                compressType = opt.compressType
        }
        if src[3] == 1 {
                isRaw = true
        }

        // unseal encrypted inf
        encryptedInfLength := binary.LittleEndian.Uint32(inf[4:])
        _, src = src[:encryptedInfLength], src[encryptedInfLength:]

        // unseal context
        contextLengthBytes, src := src[:8], src[8:]
        contextLength := binary.LittleEndian.Uint64(contextLengthBytes)
        if contextLength > 0 {
                var contextBytes []byte
                contextBytes, src = src[:contextLength], src[contextLength:]
                ctx = fusCtx.New(fusCtx.Context(contextBytes))
        }

        // unseal data type
        inf, src = src[:8], src[8:]
        structNameLength := binary.LittleEndian.Uint64(inf)
        _, src = src[:structNameLength], src[structNameLength:]

        // unseal data
        // unseal data length
        _, src = src[:8], src[8:]
        // binary.LittleEndian.Uint64(src[:8])

        // unseal data
        if compressType.IsValid() {
                dst, err = encode.From(src).Decode(encode.Compress(compressType)).ToBytes()
        } else {
                dst = src
        }
        return
}

func defaultUnseal

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/util/payload/unseal.go:

func defaultUnseal(src []byte, opts ...utils.OptionExtender) (ctx context.Context, dst any, ok bool, err error) {
        opt := utils.ApplyOptions[option](opts...)
        if opt.compressType.IsValid() {
                if src, err = encode.From(src).Decode(encode.Compress(opt.compressType)).ToBytes(); err != nil {
                        return
                }
        }
        if !opt.serializeType.IsValid() {
                // try to convert directly
                srcVal := reflect.ValueOf(src)
                if srcVal.CanConvert(opt.dataType) {
                        return nil, srcVal.Convert(opt.dataType).Interface(), false, nil
                }

                // try to map the structure
                out := reflect.New(opt.dataType).Interface()
                if err = mapstructure.Decode(src, out); err != nil {
                        return
                }
                dst = reflect.ValueOf(out).Elem()
                return
        }
        unmarshalFunc := serialize.UnmarshalFuncByType(opt.serializeType, opt.dataType, serialize.JsonEscapeHTML(false))
        dst, err = unmarshalFunc(src)
        return
}

func @53:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/util/payload/types.go:

53	`func(o *option) {`
54	`o.version = ver`
55	`}`

func Version

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/internal/util/payload/types.go:

func Version(ver uint8) utils.OptionFunc[option] {
        return func(o *option) {
                o.version = ver
        }
}

Package Overview: github.com/wfusion/gofusion/lock 80.9%

Please select a function to see what's left for testing.

`redisLuaLocker.Lock(...)`	`github.com/wfusion/gofusion/lock/redis.go`	`100.0%`	`9/9`
`Construct(...)`	`github.com/wfusion/gofusion/lock/construct.go`	`100.0%`	`7/7`
`mysqlLocker.isLocked(...)`	`github.com/wfusion/gofusion/lock/mysql.go`	`100.0%`	`4/4`
`@31:9(...)`	`github.com/wfusion/gofusion/lock/construct.go`	`100.0%`	`4/4`
`redisLuaLocker.Unlock(...)`	`github.com/wfusion/gofusion/lock/redis.go`	`100.0%`	`3/3`
`redisNXLocker.Unlock(...)`	`github.com/wfusion/gofusion/lock/redis.go`	`100.0%`	`2/2`
`@90:9(...)`	`github.com/wfusion/gofusion/lock/construct.go`	`100.0%`	`1/1`
`Expire(...)`	`github.com/wfusion/gofusion/lock/types.go`	`100.0%`	`1/1`
`redisNXLocker.formatLockKey(...)`	`github.com/wfusion/gofusion/lock/redis.go`	`100.0%`	`1/1`
`AppName(...)`	`github.com/wfusion/gofusion/lock/construct.go`	`100.0%`	`1/1`
`@54:9(...)`	`github.com/wfusion/gofusion/lock/types.go`	`100.0%`	`1/1`
`@72:8(...)`	`github.com/wfusion/gofusion/lock/candy.go`	`100.0%`	`1/1`
`newRedisNXLocker(...)`	`github.com/wfusion/gofusion/lock/redis.go`	`100.0%`	`1/1`
`init(...)`	`github.com/wfusion/gofusion/lock/construct.go`	`100.0%`	`1/1`
`redisLuaLocker.formatLockKey(...)`	`github.com/wfusion/gofusion/lock/redis.go`	`100.0%`	`1/1`
`@31:9(...)`	`github.com/wfusion/gofusion/lock/candy.go`	`100.0%`	`1/1`
`ReentrantKey(...)`	`github.com/wfusion/gofusion/lock/types.go`	`100.0%`	`1/1`
`newRedisLuaLocker(...)`	`github.com/wfusion/gofusion/lock/redis.go`	`100.0%`	`1/1`
`mongoLocker.formatLockKey(...)`	`github.com/wfusion/gofusion/lock/mongo.go`	`100.0%`	`1/1`
`newMysqlLocker(...)`	`github.com/wfusion/gofusion/lock/mysql.go`	`100.0%`	`1/1`
`mysqlLocker.formatLockKey(...)`	`github.com/wfusion/gofusion/lock/mysql.go`	`100.0%`	`1/1`
`@60:9(...)`	`github.com/wfusion/gofusion/lock/types.go`	`100.0%`	`1/1`
`mongoLocker.Lock(...)`	`github.com/wfusion/gofusion/lock/mongo.go`	`93.8%`	`15/16`
`redisNXLocker.Lock(...)`	`github.com/wfusion/gofusion/lock/redis.go`	`91.7%`	`11/12`
`@30:19(...)`	`github.com/wfusion/gofusion/lock/candy.go`	`91.7%`	`11/12`
`mongoLocker.Unlock(...)`	`github.com/wfusion/gofusion/lock/mongo.go`	`91.7%`	`11/12`
`mysqlLocker.Unlock(...)`	`github.com/wfusion/gofusion/lock/mysql.go`	`85.7%`	`6/7`
`mysqlLocker.Lock(...)`	`github.com/wfusion/gofusion/lock/mysql.go`	`82.6%`	`19/23`
`addInstance(...)`	`github.com/wfusion/gofusion/lock/construct.go`	`82.6%`	`19/23`
`Within(...)`	`github.com/wfusion/gofusion/lock/candy.go`	`80.0%`	`16/20`
`Use(...)`	`github.com/wfusion/gofusion/lock/construct.go`	`80.0%`	`8/10`
`redisLuaLocker.ReentrantLock(...)`	`github.com/wfusion/gofusion/lock/redis.go`	`75.0%`	`3/4`
`mongoLocker.ReentrantLock(...)`	`github.com/wfusion/gofusion/lock/mongo.go`	`75.0%`	`3/4`
`@70:3(...)`	`github.com/wfusion/gofusion/lock/mysql.go`	`73.3%`	`11/15`
`newMongoLocker(...)`	`github.com/wfusion/gofusion/lock/mongo.go`	`70.6%`	`12/17`
`UseReentrant(...)`	`github.com/wfusion/gofusion/lock/construct.go`	`0.0%`	`0/13`
`@78:5(...)`	`github.com/wfusion/gofusion/lock/construct.go`	`0.0%`	`0/1`
`@75:22(...)`	`github.com/wfusion/gofusion/lock/construct.go`	`0.0%`	`0/1`

func redisLuaLocker.Lock

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/redis.go:

func (r *redisLuaLocker) Lock(ctx context.Context, key string, opts ...utils.OptionExtender) (err error) {
        opt := utils.ApplyOptions[lockOption](opts...)
        expired := tolerance
        if opt.expired > 0 {
                expired = opt.expired
        }
        lockKey := r.formatLockKey(key)
        err = redis.
                Use(ctx, r.redisName, redis.AppName(r.appName)).
                Eval(ctx, redisLuaLockCommand, []string{lockKey}, []string{
                        opt.reentrantKey, strconv.Itoa(int(expired / time.Millisecond)),
                }).
                Err()
        if errors.Is(err, rdsDrv.Nil) {
                return ErrTimeout
        }
        return
}

func Construct

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/construct.go:

func Construct(ctx context.Context, confs map[string]*Conf, opts ...utils.OptionExtender) func() {
        opt := utils.ApplyOptions[config.InitOption](opts...)
        optU := utils.ApplyOptions[useOption](opts...)
        if opt.AppName == "" {
                opt.AppName = optU.appName
        }
        for name, conf := range confs {
                addInstance(ctx, name, conf, opt)
        }

        return func() {
                rwlock.Lock()
                defer rwlock.Unlock()
                if appInstances != nil {
                        delete(appInstances, opt.AppName)
                }
        }
}

func mysqlLocker.isLocked

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/mysql.go:

func (m *mysqlLocker) isLocked(ctx context.Context, lockKey string) (locked bool) {
        m.locker.RLock()
        defer m.locker.RUnlock()
        _, locked = m.lockTimers[lockKey]
        return
}

func @31:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/construct.go:

func() {
                rwlock.Lock()
                defer rwlock.Unlock()
                if appInstances != nil {
                        delete(appInstances, opt.AppName)
                }
        }

func redisLuaLocker.Unlock

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/redis.go:

func (r *redisLuaLocker) Unlock(ctx context.Context, key string, opts ...utils.OptionExtender) (err error) {
        opt := utils.ApplyOptions[lockOption](opts...)
        lockKey := r.formatLockKey(key)
        return redis.
                Use(ctx, r.redisName, redis.AppName(r.appName)).
                Eval(ctx, redisLuaUnlockCommand, []string{lockKey}, []string{opt.reentrantKey}).
                Err()
}

func redisNXLocker.Unlock

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/redis.go:

127	`func (r *redisNXLocker) Unlock(ctx context.Context, key string, _ ...utils.OptionExtender) (err error) {`
128	`lockKey := r.formatLockKey(key)`
129	`return redis.Use(ctx, r.redisName, redis.AppName(r.appName)).Del(ctx, lockKey).Err()`
130	`}`

func @90:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/construct.go:

90	`func(o *useOption) {`
91	`o.appName = name`
92	`}`

func Expire

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/types.go:

func Expire(expired time.Duration) utils.OptionFunc[lockOption] {
        return func(l *lockOption) {
                l.expired = expired
        }
}

func redisNXLocker.formatLockKey

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/redis.go:

132	`func (r *redisNXLocker) formatLockKey(key string) (format string) {`
133	`return fmt.Sprintf("%s:%s", config.Use(r.appName).AppName(), key)`
134	`}`

func AppName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/construct.go:

func AppName(name string) utils.OptionFunc[useOption] {
        return func(o *useOption) {
                o.appName = name
        }
}

func @54:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/types.go:

54	`func(l *lockOption) {`
55	`l.expired = expired`
56	`}`

func @72:8

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/candy.go:

72	`func() { err = multierr.Append(err, locker.Unlock(ctx, key, optionals...)) }`

func newRedisNXLocker

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/redis.go:

105	`func newRedisNXLocker(ctx context.Context, appName, redisName string) Lockable {`
106	`return &redisNXLocker{ctx: ctx, appName: appName, redisName: redisName}`
107	`}`

func init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/construct.go:

132	`func init() {`
133	`config.AddComponent(config.ComponentLock, Construct)`
134	`}`

func redisLuaLocker.formatLockKey

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/redis.go:

95	`func (r *redisLuaLocker) formatLockKey(key string) (format string) {`
96	`return fmt.Sprintf("%s:%s", config.Use(r.appName).AppName(), key)`
97	`}`

func @31:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/candy.go:

31	`func() { done <- struct{}{} }`

func ReentrantKey

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/types.go:

func ReentrantKey(key string) utils.OptionFunc[lockOption] {
        return func(l *lockOption) {
                l.reentrantKey = key
        }
}

func newRedisLuaLocker

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/redis.go:

54	`func newRedisLuaLocker(ctx context.Context, appName, redisName string) ReentrantLockable {`
55	`return &redisLuaLocker{ctx: ctx, appName: appName, redisName: redisName}`
56	`}`

func mongoLocker.formatLockKey

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/mongo.go:

153	`func (m *mongoLocker) formatLockKey(key string) (format string) {`
154	`return fmt.Sprintf("%s_%s", config.Use(m.appName).AppName(), key)`
155	`}`

func newMysqlLocker

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/mysql.go:

32	`func newMysqlLocker(ctx context.Context, appName, dbName string) Lockable {`
33	`return &mysqlLocker{ctx: ctx, appName: appName, dbName: dbName, lockTimers: map[string]struct{}{}}`
34	`}`

func mysqlLocker.formatLockKey

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/mysql.go:

119	`func (m *mysqlLocker) formatLockKey(key string) string {`
120	`return fmt.Sprintf("%s:%s", config.Use(m.appName).AppName(), key)`
121	`}`

func @60:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/types.go:

60	`func(l *lockOption) {`
61	`l.reentrantKey = key`
62	`}`

func mongoLocker.Lock

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/mongo.go:

func (m *mongoLocker) Lock(ctx context.Context, key string, opts ...utils.OptionExtender) (err error) {
        opt := utils.ApplyOptions[lockOption](opts...)
        expired := tolerance
        if opt.expired > 0 {
                expired = opt.expired
        }
        now := time.Now()
        lockKey := m.formatLockKey(key)
        filter := bson.M{
                "lock_key": bson.M{"$eq": lockKey, "$exists": true},
                "$or": []bson.M{
                        {"expires_at": bson.M{"$lt": now, "$exists": true}},
                        {"holder": bson.M{"$eq": opt.reentrantKey, "$exists": true}},
                },
        }
        update := bson.M{
                "$setOnInsert": bson.M{
                        "lock_key": lockKey,
                        "holder":   opt.reentrantKey,
                },
                "$inc": bson.M{"count": 1},
                "$max": bson.M{"expires_at": now.Add(expired)},
        }
        mopts := options.FindOneAndUpdate().SetUpsert(true).SetReturnDocument(options.After)

        updatedDoc := new(mongoLockDoc)
        err = mongo.Use(m.mongoName, mongo.AppName(m.appName), mongo.WriteConcern(writeconcern.Majority())).
                Collection(m.collName).
                FindOneAndUpdate(ctx, filter, update, mopts).
                Decode(updatedDoc)
        if err != nil {
                return
        }

        if updatedDoc.LockKey == lockKey && updatedDoc.Holder == opt.reentrantKey {
                return
        }

        return ErrTimeout
}

func redisNXLocker.Lock

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/redis.go:

func (r *redisNXLocker) Lock(ctx context.Context, key string, opts ...utils.OptionExtender) (err error) {
        opt := utils.ApplyOptions[lockOption](opts...)
        expired := tolerance
        if opt.expired > 0 {
                expired = opt.expired
        }
        lockKey := r.formatLockKey(key)
        cmd := redis.Use(ctx, r.redisName, redis.AppName(r.appName)).SetNX(ctx, lockKey, utils.UUID(), expired)
        if err = cmd.Err(); err != nil {
                return
        }
        if !cmd.Val() {
                err = ErrTimeout
                return
        }
        return
}

func @30:19

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/candy.go:

func() {
                defer func() { done <- struct{}{} }()

                var e error
                rLocker, ok := locker.(ReentrantLockable)
                for {
                        select {
                        case <-timeFault: // timeout exit
                                return
                        default:
                                if ok {
                                        if e = rLocker.ReentrantLock(ctx, key, optL.reentrantKey, optionals...); e == nil {
                                                return
                                        }
                                } else {
                                        if e = locker.Lock(ctx, key, optionals...); e == nil {
                                                return
                                        }
                                }

                                // relock after 200 milliseconds
                                time.Sleep(reLockWaitTime)
                        }
                }
        }

func mongoLocker.Unlock

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/mongo.go:

func (m *mongoLocker) Unlock(ctx context.Context, key string, opts ...utils.OptionExtender) (err error) {
        opt := utils.ApplyOptions[lockOption](opts...)
        filter := bson.M{
                "lock_key": m.formatLockKey(key),
                "holder":   opt.reentrantKey,
                "count":    bson.M{"$gt": 0},
        }
        update := bson.M{
                "$inc": bson.M{"count": -1},
                "$max": bson.M{"expires_at": time.Now().Add(opt.expired / 2)},
        }
        mopts := options.FindOneAndUpdate().SetReturnDocument(options.After)

        updatedDoc := new(mongoLockDoc)
        coll := mongo.
                Use(m.mongoName, mongo.AppName(m.appName), mongo.WriteConcern(writeconcern.Majority())).
                Collection(m.collName)
        err = coll.FindOneAndUpdate(ctx, filter, update, mopts).Decode(&updatedDoc)
        if err != nil {
                return
        }
        if updatedDoc.Count <= 0 {
                _, err = coll.DeleteOne(ctx, bson.M{
                        "lock_key": m.formatLockKey(key),
                        "holder":   opt.reentrantKey,
                        "count":    bson.M{"$lte": 0},
                })
        }

        return
}

func mysqlLocker.Unlock

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/mysql.go:

func (m *mysqlLocker) Unlock(ctx context.Context, key string, _ ...utils.OptionExtender) (err error) {
        lockKey := m.formatLockKey(key)
        if err = db.Use(ctx, m.dbName, db.AppName(m.appName)).Raw(mysqlUnlockSQL, lockKey).Error; err != nil {
                return
        }
        m.locker.Lock()
        defer m.locker.Unlock()
        delete(m.lockTimers, lockKey)

        return
}

func mysqlLocker.Lock

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/mysql.go:

func (m *mysqlLocker) Lock(ctx context.Context, key string, opts ...utils.OptionExtender) (err error) {
        opt := utils.ApplyOptions[lockOption](opts...)
        expired := tolerance
        if opt.expired > 0 {
                expired = opt.expired
        }
        lockKey := m.formatLockKey(key)
        if len(lockKey) > 64 {
                return errors.Errorf("key %s length is too long, max key length is 64", lockKey)
        }

        m.locker.Lock()
        defer m.locker.Unlock()
        // disable reentrant
        if _, ok := m.lockTimers[lockKey]; ok {
                return ErrTimeout
        }

        ret := db.Use(ctx, m.dbName, db.AppName(m.appName)).Raw(mysqlLockSQL, lockKey, 0)
        if err = ret.Error; err != nil {
                return ret.Error
        }
        var result int64
        if err = ret.Scan(&result).Error; err != nil {
                return
        }
        if result != 1 {
                return ErrTimeout
        }

        // expire loop
        m.lockTimers[lockKey] = struct{}{}
        timer := time.NewTimer(expired)
        routine.Loop(
                func(ctx context.Context, key string, timer *time.Timer) {
                        defer timer.Stop()

                        lockKey := m.formatLockKey(key)
                        if !m.isLocked(ctx, lockKey) {
                                return
                        }

                        for {
                                select {
                                case <-ctx.Done():
                                        _ = m.Unlock(ctx, key) // context done
                                        return
                                case <-m.ctx.Done():
                                        _ = m.Unlock(ctx, key) // context done
                                        return
                                case <-timer.C:
                                        _ = m.Unlock(ctx, key) // timeout
                                        return
                                default:
                                        if !m.isLocked(ctx, lockKey) {
                                                return
                                        }
                                        time.Sleep(200*time.Millisecond + time.Duration(rand.Int63())%(100*time.Millisecond))
                                }
                        }
                }, routine.Args(ctx, key, timer), routine.AppName(m.appName))
        return
}

func addInstance

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/construct.go:

func addInstance(ctx context.Context, name string, conf *Conf, opt *config.InitOption) {
        rwlock.Lock()
        defer rwlock.Unlock()
        if appInstances == nil {
                appInstances = make(map[string]map[string]Lockable)
        }
        if appInstances[opt.AppName] == nil {
                appInstances[opt.AppName] = make(map[string]Lockable)
        }

        if _, ok := appInstances[opt.AppName][name]; ok {
                panic(ErrDuplicatedName)
        }

        switch conf.Type {
        case lockTypeRedisLua:
                redis.Use(ctx, conf.Instance, redis.AppName(opt.AppName)) // check if instance exists
                appInstances[opt.AppName][name] = newRedisLuaLocker(ctx, opt.AppName, conf.Instance)
        case lockTypeRedisNX:
                redis.Use(ctx, conf.Instance, redis.AppName(opt.AppName)) // check if instance exists
                appInstances[opt.AppName][name] = newRedisNXLocker(ctx, opt.AppName, conf.Instance)
        case lockTypeMySQL:
                db.Use(ctx, conf.Instance, db.AppName(opt.AppName)) // check if instance exists
                appInstances[opt.AppName][name] = newMysqlLocker(ctx, opt.AppName, conf.Instance)
        case lockTypeMariaDB:
                db.Use(ctx, conf.Instance, db.AppName(opt.AppName)) // check if instance exists
                appInstances[opt.AppName][name] = newMysqlLocker(ctx, opt.AppName, conf.Instance)
        case lockTypeMongo:
                appInstances[opt.AppName][name] = newMongoLocker(ctx, opt.AppName, conf.Instance, conf.Scheme)
        default:
                panic(ErrUnsupportedLockType)
        }

        // ioc
        if opt.DI != nil {
                opt.DI.MustProvide(func() Lockable { return Use(name, AppName(opt.AppName)) }, di.Name(name))
                if _, ok := appInstances[opt.AppName][name].(ReentrantLockable); ok {
                        opt.DI.MustProvide(
                                func() ReentrantLockable { return UseReentrant(ctx, name, AppName(opt.AppName)) },
                                di.Name(name),
                        )
                }
        }
}

func Within

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/candy.go:

func Within(ctx context.Context, locker Lockable, key string,
        expired, timeout time.Duration, cb func() error, opts ...utils.OptionExtender) (err error) {
        const (
                reLockWaitTime = time.Duration(200) * time.Millisecond
        )
        opt := utils.ApplyOptions[useOption](opts...)
        optL := utils.ApplyOptions[lockOption](opts...)
        if optL.reentrantKey == "" {
                optL.reentrantKey = utils.ULID()
        }
        optionals := []utils.OptionExtender{ReentrantKey(optL.reentrantKey)}
        if expired > 0 {
                optionals = append(optionals, Expire(expired))
        }

        done := make(chan struct{}, 1)
        timeFault := make(chan struct{}, 1)
        routine.Goc(ctx, func() {
                defer func() { done <- struct{}{} }()

                var e error
                rLocker, ok := locker.(ReentrantLockable)
                for {
                        select {
                        case <-timeFault: // timeout exit
                                return
                        default:
                                if ok {
                                        if e = rLocker.ReentrantLock(ctx, key, optL.reentrantKey, optionals...); e == nil {
                                                return
                                        }
                                } else {
                                        if e = locker.Lock(ctx, key, optionals...); e == nil {
                                                return
                                        }
                                }

                                // relock after 200 milliseconds
                                time.Sleep(reLockWaitTime)
                        }
                }
        }, routine.AppName(opt.appName))

        timer := time.NewTimer(timeout)
        select {
        // success
        case <-done:

        // context done
        case <-ctx.Done():
                timeFault <- struct{}{}
                return ErrContextDone

        // timeout
        case <-timer.C:
                timeFault <- struct{}{}
                return ErrTimeout
        }

        defer func() { err = multierr.Append(err, locker.Unlock(ctx, key, optionals...)) }()

        _, err = utils.Catch(cb)
        return
}

func Use

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/construct.go:

func Use(name string, opts ...utils.OptionExtender) Lockable {
        opt := utils.ApplyOptions[useOption](opts...)

        rwlock.RLock()
        defer rwlock.RUnlock()
        instances, ok := appInstances[opt.appName]
        if !ok {
                panic(errors.Errorf("locker instance not found for app: %s", opt.appName))
        }
        instance, ok := instances[name]
        if !ok {
                panic(errors.Errorf("locker instance not found for name: %s", name))
        }
        return instance
}

func redisLuaLocker.ReentrantLock

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/redis.go:

func (r *redisLuaLocker) ReentrantLock(ctx context.Context, key, reentrantKey string,
        opts ...utils.OptionExtender) (err error) {
        opt := utils.ApplyOptions[lockOption](opts...)
        if utils.IsStrBlank(opt.reentrantKey) {
                return ErrReentrantKeyNotFound
        }
        return r.Lock(ctx, key, append(opts, ReentrantKey(reentrantKey))...)
}

func mongoLocker.ReentrantLock

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/mongo.go:

func (m *mongoLocker) ReentrantLock(ctx context.Context, key, reentrantKey string,
        opts ...utils.OptionExtender) (err error) {
        opt := utils.ApplyOptions[lockOption](opts...)
        if utils.IsStrBlank(opt.reentrantKey) {
                return ErrReentrantKeyNotFound
        }
        return m.Lock(ctx, key, append(opts, ReentrantKey(reentrantKey))...)
}

func @70:3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/mysql.go:

func(ctx context.Context, key string, timer *time.Timer) {
                        defer timer.Stop()

                        lockKey := m.formatLockKey(key)
                        if !m.isLocked(ctx, lockKey) {
                                return
                        }

                        for {
                                select {
                                case <-ctx.Done():
                                        _ = m.Unlock(ctx, key) // context done
                                        return
                                case <-m.ctx.Done():
                                        _ = m.Unlock(ctx, key) // context done
                                        return
                                case <-timer.C:
                                        _ = m.Unlock(ctx, key) // timeout
                                        return
                                default:
                                        if !m.isLocked(ctx, lockKey) {
                                                return
                                        }
                                        time.Sleep(200*time.Millisecond + time.Duration(rand.Int63())%(100*time.Millisecond))
                                }
                        }
                }

func newMongoLocker

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/mongo.go:

func newMongoLocker(ctx context.Context, appName, mongoName, collName string) Lockable {
        mongoInitLocker.Lock()
        defer mongoInitLocker.Unlock()

        db := mongo.Use(mongoName, mongo.AppName(appName), mongo.WriteConcern(writeconcern.Majority()))
        coll := db.Collection(collName)
        colls, err := db.ListCollectionNames(ctx, bson.M{"name": collName})
        if err != nil {
                panic(errors.Errorf("%s lock component mongo %s parse collection %s failed: %s",
                        appName, mongoName, collName, err))
        }
        if len(colls) == 0 {
                if err = db.CreateCollection(ctx, collName); err != nil {
                        panic(errors.Errorf("%s lock component mongo %s create collection %s failed: %s",
                                appName, mongoName, collName, err))
                }
        }

        ttlIdxModel := mgoDrv.IndexModel{
                Keys:    bson.M{"expires_at": 1},
                Options: options.Index().SetExpireAfterSeconds(0),
        }
        if _, err = coll.Indexes().CreateOne(ctx, ttlIdxModel); err != nil {
                panic(errors.Errorf("%s lock component mongo %s create ttl index %s failed: %s",
                        appName, mongoName, collName, err))
        }

        indexModel := mgoDrv.IndexModel{
                Keys:    bson.M{"lock_key": 1},
                Options: options.Index().SetUnique(true),
        }
        if _, err = coll.Indexes().CreateOne(ctx, indexModel); err != nil {
                panic(errors.Errorf("%s lock component mongo %s create lock index %s failed: %s",
                        appName, mongoName, collName, err))
        }

        return &mongoLocker{ctx: ctx, appName: appName, mongoName: mongoName, collName: collName}
}

func UseReentrant

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/construct.go:

func UseReentrant(ctx context.Context, name string, opts ...utils.OptionExtender) ReentrantLockable {
        opt := utils.ApplyOptions[useOption](opts...)

        rwlock.RLock()
        defer rwlock.RUnlock()
        instances, ok := appInstances[opt.appName]
        if !ok {
                panic(errors.Errorf("reentrant locker instance not found for app: %s", opt.appName))
        }
        instance, ok := instances[name]
        if !ok {
                panic(errors.Errorf("reentrant locker instance not found for name: %s", name))
        }
        lockable, ok := instance.(ReentrantLockable)
        if !ok {
                panic(errors.Errorf("locker instance is not reentrantable: %s", name))
        }

        return lockable
}

func @78:5

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/construct.go:

78	`func() ReentrantLockable { return UseReentrant(ctx, name, AppName(opt.AppName)) }`

func @75:22

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/lock/construct.go:

75	`func() Lockable { return Use(name, AppName(opt.AppName)) }`

Package Overview: github.com/wfusion/gofusion/log 72.6%

Please select a function to see what's left for testing.

`@40:9(...)`	`github.com/wfusion/gofusion/log/construct.go`	`100.0%`	`11/11`
`logger.flush(...)`	`github.com/wfusion/gofusion/log/logger.go`	`100.0%`	`6/6`
`getEncoderConfig(...)`	`github.com/wfusion/gofusion/log/utils.go`	`100.0%`	`4/4`
`convertFieldsToZapFields(...)`	`github.com/wfusion/gofusion/log/context.go`	`100.0%`	`4/4`
`zapLogLevel.Enabled(...)`	`github.com/wfusion/gofusion/log/utils.go`	`100.0%`	`3/3`
`newZapLogLevel(...)`	`github.com/wfusion/gofusion/log/utils.go`	`100.0%`	`3/3`
`@86:4(...)`	`github.com/wfusion/gofusion/log/construct.go`	`100.0%`	`2/2`
`@87:4(...)`	`github.com/wfusion/gofusion/log/construct.go`	`100.0%`	`2/2`
`GetCtxLogger(...)`	`github.com/wfusion/gofusion/log/context.go`	`100.0%`	`1/1`
`init(...)`	`github.com/wfusion/gofusion/log/construct.go`	`100.0%`	`1/1`
`SetContextFields(...)`	`github.com/wfusion/gofusion/log/candy.go`	`100.0%`	`1/1`
`@40:9(...)`	`github.com/wfusion/gofusion/log/logger.go`	`100.0%`	`1/1`
`Info(...)`	`github.com/wfusion/gofusion/log/candy.go`	`100.0%`	`1/1`
`AppName(...)`	`github.com/wfusion/gofusion/log/logger.go`	`100.0%`	`1/1`
`logger.sweeten(...)`	`github.com/wfusion/gofusion/log/logger.go`	`90.9%`	`20/22`
`Construct(...)`	`github.com/wfusion/gofusion/log/construct.go`	`90.0%`	`9/10`
`addInstance(...)`	`github.com/wfusion/gofusion/log/construct.go`	`88.4%`	`38/43`
`defaultLogger(...)`	`github.com/wfusion/gofusion/log/logger.go`	`85.7%`	`6/7`
`getContextZapFields(...)`	`github.com/wfusion/gofusion/log/context.go`	`85.7%`	`6/7`
`zapLogLevel.reloadConfig(...)`	`github.com/wfusion/gofusion/log/utils.go`	`80.0%`	`12/15`
`logger.Debug(...)`	`github.com/wfusion/gofusion/log/logger.go`	`75.0%`	`3/4`
`logger.Warn(...)`	`github.com/wfusion/gofusion/log/logger.go`	`75.0%`	`3/4`
`logger.Info(...)`	`github.com/wfusion/gofusion/log/logger.go`	`75.0%`	`3/4`
`@138:12(...)`	`github.com/wfusion/gofusion/log/logger.go`	`75.0%`	`3/4`
`getEncoder(...)`	`github.com/wfusion/gofusion/log/utils.go`	`75.0%`	`3/4`
`Use(...)`	`github.com/wfusion/gofusion/log/logger.go`	`62.5%`	`10/16`
`getLogLevel(...)`	`github.com/wfusion/gofusion/log/utils.go`	`62.5%`	`5/8`
`@23:8(...)`	`github.com/wfusion/gofusion/log/candy.go`	`0.0%`	`0/6`
`logger.Error(...)`	`github.com/wfusion/gofusion/log/logger.go`	`0.0%`	`0/4`
`logger.Panic(...)`	`github.com/wfusion/gofusion/log/logger.go`	`0.0%`	`0/4`
`logger.Fatal(...)`	`github.com/wfusion/gofusion/log/logger.go`	`0.0%`	`0/4`
`@92:4(...)`	`github.com/wfusion/gofusion/log/construct.go`	`0.0%`	`0/3`
`TimeElapsed(...)`	`github.com/wfusion/gofusion/log/candy.go`	`0.0%`	`0/3`
`@88:4(...)`	`github.com/wfusion/gofusion/log/construct.go`	`0.0%`	`0/2`
`Debug(...)`	`github.com/wfusion/gofusion/log/candy.go`	`0.0%`	`0/1`
`GetContextFields(...)`	`github.com/wfusion/gofusion/log/candy.go`	`0.0%`	`0/1`
`@157:4(...)`	`github.com/wfusion/gofusion/log/construct.go`	`0.0%`	`0/1`
`SetCtxLogger(...)`	`github.com/wfusion/gofusion/log/context.go`	`0.0%`	`0/1`
`Panic(...)`	`github.com/wfusion/gofusion/log/candy.go`	`0.0%`	`0/1`
`Error(...)`	`github.com/wfusion/gofusion/log/candy.go`	`0.0%`	`0/1`
`Warn(...)`	`github.com/wfusion/gofusion/log/candy.go`	`0.0%`	`0/1`
`Fatal(...)`	`github.com/wfusion/gofusion/log/candy.go`	`0.0%`	`0/1`

func @40:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/construct.go:

func() {
                rwlock.Lock()
                defer rwlock.Unlock()
                if appInstances != nil {
                        for _, instance := range appInstances[opt.AppName] {
                                instance.flush()
                        }
                        delete(appInstances, opt.AppName)
                }

                // there maybe some locally logging, avoid some NPE crash as possible as we can do
                colorful := false
                if opt.AppName == "" {
                        if confs != nil && confs[config.DefaultInstanceKey] != nil {
                                colorful = confs[config.DefaultInstanceKey].ConsoleOutputOption.Colorful
                        }
                        globalLogger = defaultLogger(colorful)
                }
        }

func logger.flush

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/logger.go:

func (l *logger) flush() {
        ignore := func(err error) bool {
                // ENOTTY:
                //     ignore sync /dev/stdout: inappropriate ioctl for device errors,
                //     which happens when redirect stderr to stdout
                // EINVAL:
                //     ignore sync /dev/stdout: invalid argument
                for _, target := range []error{syscall.EINVAL, syscall.ENOTTY} {
                        if errors.Is(err, target) {
                                return true
                        }
                }
                return false
        }

        pid := syscall.Getpid()
        if _, err := utils.Catch(l.logger.Sync); err != nil && !ignore(err) {
                log.Printf("%v [Gofusion] %s flush %s logger error: %s", pid, config.ComponentLog, l.name, err)
        }
        if _, err := utils.Catch(l.sugaredLogger.Sync); err != nil && !ignore(err) {
                log.Printf("%v [Gofusion] %s flush %s sugared logger error: %s",
                        pid, config.ComponentLog, l.name, err)
        }
}

func getEncoderConfig

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/utils.go:

func getEncoderConfig(conf *Conf) zapcore.EncoderConfig {
        skips := make([]string, 0, len(encoder.SkipCallers)+len(conf.SkipCallers))
        skips = append(skips, encoder.SkipCallers...)
        skips = append(skips, conf.SkipCallers...)
        return zapcore.EncoderConfig{
                LevelKey:       "L",
                TimeKey:        "T",
                MessageKey:     "M",
                NameKey:        "N",
                CallerKey:      "C",
                StacktraceKey:  "S",
                LineEnding:     zapcore.DefaultLineEnding,
                EncodeLevel:    zapcore.CapitalLevelEncoder,
                EncodeTime:     zapcore.ISO8601TimeEncoder,
                EncodeDuration: zapcore.SecondsDurationEncoder,
                EncodeCaller:   encoder.SkipCallerEncoder(skips, conf.ShorterFilepath),
        }
}

func convertFieldsToZapFields

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/context.go:

func convertFieldsToZapFields(fields Fields) (zapFields []zap.Field) {
        zapFields = make([]zap.Field, 0, len(fields))
        for k, v := range fields {
                zapFields = append(zapFields, zap.Any(k, v))
        }
        return
}

func zapLogLevel.Enabled

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/utils.go:

func (z *zapLogLevel) Enabled(level zapcore.Level) bool {
        if z.reloadConfig(); !z.enabled {
                return false
        }

        return level >= z.Level
}

func newZapLogLevel

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/utils.go:

func newZapLogLevel(appName, confName, enableField, levelField string) zapcore.LevelEnabler {
        z := &zapLogLevel{
                enabled:     true,
                appName:     config.Use(appName).AppName(),
                confName:    confName,
                enableField: enableField,
                levelField:  levelField,
        }
        z.reloadConfig()
        return z
}

func @86:4

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/construct.go:

86	`func() bool { logName = conf.FileOutputOption.Name; return utils.IsStrNotBlank(logName) }`

func @87:4

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/construct.go:

87	`func() bool { logName = config.Use(opt.AppName).AppName() + ext; return utils.IsStrNotBlank(logName) }`

func GetCtxLogger

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/context.go:

35	`func GetCtxLogger(ctx context.Context, args ...Loggable) (logger Loggable) {`
36	`return utils.GetCtxAny(ctx, fusCtx.KeyLoggable, args...)`
37	`}`

func init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/construct.go:

163	`func init() {`
164	`config.AddComponent(config.ComponentLog, Construct)`
165	`}`

func SetContextFields

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/candy.go:

42	`func SetContextFields(ctx context.Context, fields Fields) context.Context {`
43	`return utils.SetCtxAny(ctx, fusCtx.KeyLogFields, fields)`
44	`}`

func @40:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/logger.go:

40	`func(o *useOption) {`
41	`o.appName = name`
42	`}`

func Info

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/candy.go:

15	`func Info(ctx context.Context, format string, args ...any) { globalLogger.Info(ctx, format, args...) }`

func AppName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/logger.go:

func AppName(name string) utils.OptionFunc[useOption] {
        return func(o *useOption) {
                o.appName = name
        }
}

func logger.sweeten

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/logger.go:

func (l *logger) sweeten(ctx context.Context, format string, raw ...any) (
        log Loggable, msg string, fields []zap.Field) {
        args := make([]any, 0, len(raw))
        fields = getContextZapFields(ctx)
        for _, arg := range raw {
                if f, ok := arg.(Fields); ok {
                        fields = append(fields, convertFieldsToZapFields(f)...)
                        continue
                }
                args = append(args, arg)
        }

        msg = fmt.Sprintf(format, args...)
        if userID := fusCtx.GetUserID(ctx); utils.IsStrNotBlank(userID) {
                fields = append(fields, zap.String("user_id", userID))
        }
        if traceID := fusCtx.GetTraceID(ctx); utils.IsStrNotBlank(traceID) {
                fields = append(fields, zap.String("trace_id", traceID))
        }
        if taskID := fusCtx.GetCronTaskID(ctx); utils.IsStrNotBlank(taskID) {
                fields = append(fields, zap.String("cron_task_id", taskID))
        }
        if taskName := fusCtx.GetCronTaskName(ctx); utils.IsStrNotBlank(taskName) {
                fields = append(fields, zap.String("cron_task_name", taskName))
        }
        if id := utils.GetCtxAny[string](ctx, watermill.ContextKeyMessageUUID); utils.IsStrNotBlank(id) {
                fields = append(fields, zap.String("message_uuid", id))
        }
        if id := utils.GetCtxAny[string](ctx, watermill.ContextKeyRawMessageID); utils.IsStrNotBlank(id) {
                fields = append(fields, zap.String("message_raw_id", id))
        }

        log = GetCtxLogger(ctx, l)
        return
}

func Construct

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/construct.go:

func Construct(ctx context.Context, confs map[string]*Conf, opts ...utils.OptionExtender) func() {
        opt := utils.ApplyOptions[config.InitOption](opts...)
        optU := utils.ApplyOptions[useOption](opts...)
        if opt.AppName == "" {
                opt.AppName = optU.appName
        }
        for name, conf := range confs {
                addInstance(ctx, name, conf, opt)
        }

        if opt.AppName == "" && appInstances[opt.AppName] != nil {
                if conf, ok := appInstances[opt.AppName][config.DefaultInstanceKey]; !ok || conf == nil {
                        panic(ErrDefaultLoggerNotFound)
                }
        }

        return func() {
                rwlock.Lock()
                defer rwlock.Unlock()
                if appInstances != nil {
                        for _, instance := range appInstances[opt.AppName] {
                                instance.flush()
                        }
                        delete(appInstances, opt.AppName)
                }

                // there maybe some locally logging, avoid some NPE crash as possible as we can do
                colorful := false
                if opt.AppName == "" {
                        if confs != nil && confs[config.DefaultInstanceKey] != nil {
                                colorful = confs[config.DefaultInstanceKey].ConsoleOutputOption.Colorful
                        }
                        globalLogger = defaultLogger(colorful)
                }
        }
}

func addInstance

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/construct.go:

func addInstance(ctx context.Context, name string, conf *Conf, opt *config.InitOption) {
        if !conf.EnableFileOutput && !conf.EnableConsoleOutput {
                panic(ErrUnknownOutput)
        }

        var cores []zapcore.Core
        if conf.EnableConsoleOutput {
                cfg := getEncoderConfig(conf)
                if conf.ConsoleOutputOption.Colorful {
                        cfg.EncodeLevel = zapcore.CapitalColorLevelEncoder
                }
                encoder := getEncoder(conf.ConsoleOutputOption.Layout, cfg)
                writer := zapcore.Lock(os.Stdout)
                logLevel := newZapLogLevel(opt.AppName, name, "enable_console_output", "log_level")
                cores = append(cores, zapcore.NewCore(encoder, writer, logLevel))
        }
        if conf.EnableFileOutput {
                var (
                        ext     = ".log"
                        logName string
                )

                cfg := getEncoderConfig(conf)
                encoder := getEncoder(conf.FileOutputOption.Layout, cfg)
                utils.IfAny(
                        func() bool { logName = conf.FileOutputOption.Name; return utils.IsStrNotBlank(logName) },
                        func() bool { logName = config.Use(opt.AppName).AppName() + ext; return utils.IsStrNotBlank(logName) },
                        func() bool {
                                logName = filepath.Base(env.WorkDir) + ext
                                return logName != constant.PathSeparator+".log"
                        },
                        func() bool {
                                sum := md5.Sum([]byte(env.WorkDir))
                                logName = string(sum[:]) + ext
                                return true
                        },
                )

                rotationSize, err := humanize.ParseBytes(conf.FileOutputOption.RotationSize)
                if err != nil {
                        panic(errors.Errorf("log component parse ratation size %s failed for name %s: %s",
                                conf.FileOutputOption.RotationSize, name, err))
                }

                maxAge, err := time.ParseDuration(conf.FileOutputOption.RotationMaxAge)
                if err != nil {
                        panic(errors.Errorf("log component parse ratation time %s failed for name %s: %s",
                                conf.FileOutputOption.RotationMaxAge, name, err))
                }

                writer := zapcore.AddSync(&rotatelog.Logger{
                        Filename:   path.Join(filepath.Clean(conf.FileOutputOption.Path), logName),
                        MaxSize:    int64(rotationSize),
                        MaxBackups: conf.FileOutputOption.RotationCount,
                        MaxAge:     maxAge,
                        Compress:   conf.FileOutputOption.Compress,
                })
                logLevel := newZapLogLevel(opt.AppName, name, "enable_file_output", "log_level")
                cores = append(cores, zapcore.NewCore(encoder, writer, logLevel))
        }

        zopts := []zap.Option{
                zap.Hooks(),
                zap.AddCaller(),
                zap.AddStacktrace(newZapLogLevel(opt.AppName, name, "enable_file_output", "stacktrace_level")),
        }
        if config.Use(opt.AppName).Debug() {
                zopts = append(zopts, zap.Development())
        }

        zapLogger := zap.
                New(zapcore.NewTee(cores...), zopts...).
                Named(config.Use(opt.AppName).AppName())

        fusLogger := &logger{name: name, logger: zapLogger, sugaredLogger: zapLogger.Sugar()}

        rwlock.Lock()
        defer rwlock.Unlock()
        if appInstances == nil {
                appInstances = make(map[string]map[string]*logger)
        }
        if appInstances[opt.AppName] == nil {
                appInstances[opt.AppName] = make(map[string]*logger)
        }
        if _, ok := appInstances[opt.AppName][name]; ok {
                panic(ErrDuplicatedName)
        }
        appInstances[opt.AppName][name] = fusLogger

        if opt.AppName == "" && name == config.DefaultInstanceKey {
                globalLogger = fusLogger
        }

        // ioc
        if opt.DI != nil {
                opt.DI.MustProvide(
                        func() Loggable { return Use(name, AppName(opt.AppName)) },
                        di.Name(name),
                )
        }
}

func defaultLogger

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/logger.go:

func defaultLogger(colorful bool) Loggable {
        devCfg := zap.NewDevelopmentConfig()
        devCfg.Level = zap.NewAtomicLevelAt(zap.InfoLevel)
        if colorful {
                devCfg.EncoderConfig.EncodeLevel = zapcore.CapitalColorLevelEncoder
        }
        devCfg.EncoderConfig.EncodeCaller = encoder.SkipCallerEncoder(encoder.SkipCallers, true)
        zapLogger, _ := devCfg.Build(
                zap.AddStacktrace(zap.PanicLevel),
                zap.AddCaller(),
                zap.Hooks(),
        )
        return &logger{
                logger:        zapLogger,
                sugaredLogger: zapLogger.Sugar(),
        }
}

func getContextZapFields

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/context.go:

func getContextZapFields(ctx context.Context) (zapFields []zap.Field) {
        v := ctx.Value(fusCtx.KeyLogFields)
        if v == nil {
                return
        }
        field, ok := v.(Fields)
        if !ok {
                return
        }
        return convertFieldsToZapFields(field)
}

func zapLogLevel.reloadConfig

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/utils.go:

func (z *zapLogLevel) reloadConfig() {
        var cfgs map[string]map[string]any
        _ = config.Use(z.appName).LoadComponentConfig(config.ComponentLog, &cfgs)
        if len(cfgs) == 0 {
                return
        }

        cfg, ok := cfgs[z.confName]
        if !ok {
                return
        }
        enabled := cast.ToBool(cfg[z.enableField])
        z.enabled = enabled

        logLevelObj, ok1 := cfg[z.levelField]
        logLevel, ok2 := logLevelObj.(string)
        if !ok1 || !ok2 {
                return
        }
        level := getLogLevel(logLevel)
        z.Level = level
}

func logger.Debug

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/logger.go:

func (l *logger) Debug(ctx context.Context, format string, args ...any) {
        lg, msg, fields := l.sweeten(ctx, format, args...)
        if logger, ok := lg.(*logger); ok {
                logger.logger.Debug(msg, fields...)
        } else {
                lg.Debug(ctx, msg, args...)
        }
}

func logger.Warn

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/logger.go:

func (l *logger) Warn(ctx context.Context, format string, args ...any) {
        lg, msg, fields := l.sweeten(ctx, format, args...)
        if logger, ok := lg.(*logger); ok {
                logger.logger.Warn(msg, fields...)
        } else {
                lg.Warn(ctx, msg, args...)
        }
}

func logger.Info

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/logger.go:

func (l *logger) Info(ctx context.Context, format string, args ...any) {
        lg, msg, fields := l.sweeten(ctx, format, args...)
        if logger, ok := lg.(*logger); ok {
                logger.logger.Info(msg, fields...)
        } else {
                lg.Info(ctx, msg, args...)
        }
}

func @138:12

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/logger.go:

func(err error) bool {
                // ENOTTY:
                //     ignore sync /dev/stdout: inappropriate ioctl for device errors,
                //     which happens when redirect stderr to stdout
                // EINVAL:
                //     ignore sync /dev/stdout: invalid argument
                for _, target := range []error{syscall.EINVAL, syscall.ENOTTY} {
                        if errors.Is(err, target) {
                                return true
                        }
                }
                return false
        }

func getEncoder

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/utils.go:

func getEncoder(layout string, cfg zapcore.EncoderConfig) zapcore.Encoder {
        switch strings.ToLower(layout) {
        case "json":
                return zapcore.NewJSONEncoder(cfg)
        case "console":
                return zapcore.NewConsoleEncoder(cfg)
        default:
                return zapcore.NewJSONEncoder(cfg)
        }
}

func Use

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/logger.go:

func Use(name string, opts ...utils.OptionExtender) Loggable {
        opt := utils.ApplyOptions[useOption](opts...)

        rwlock.RLock()
        defer rwlock.RUnlock()
        instances, ok := appInstances[opt.appName]
        if !ok {
                globalLogger.Debug(context.Background(), "%v [Gofusion] %s instance not found for app: %s",
                        syscall.Getpid(), config.ComponentLog, opt.appName, Fields{"component": "log"})
                return globalLogger
        }
        instance, ok := instances[name]
        if !ok {
                instance, ok = instances[config.DefaultInstanceKey]
                if ok {
                        instance.Debug(context.Background(), "%v [Gofusion] %s instance not found for name: %s",
                                syscall.Getpid(), config.ComponentLog, name, Fields{"component": "log"})
                        return instance
                }
                globalLogger.Debug(context.Background(), "%v [Gofusion] %s instance not found for name: %s",
                        syscall.Getpid(), config.ComponentLog, name, Fields{"component": "log"})
                return globalLogger
        }

        return instance
}

func getLogLevel

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/utils.go:

func getLogLevel(level string) zapcore.Level {
        switch strings.ToLower(level) {
        case "debug":
                return zap.DebugLevel
        case "info":
                return zap.InfoLevel
        case "warn":
                return zap.WarnLevel
        case "error":
                return zap.ErrorLevel
        case "panic":
                return zap.PanicLevel
        case "fatal":
                return zap.FatalLevel
        default:
                return zap.InfoLevel
        }
}

func @23:8

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/candy.go:

func() {
                elapsed := time.Since(now).Milliseconds()
                if r := recover(); r != nil {
                        panic(r)
                }
                if logger != nil {
                        logger.Info(ctx, format, append(args, zap.Any("latency", elapsed))...)
                } else {
                        Info(ctx, format, append(args, zap.Any("latency", elapsed))...)
                }
        }

func logger.Error

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/logger.go:

func (l *logger) Error(ctx context.Context, format string, args ...any) {
        lg, msg, fields := l.sweeten(ctx, format, args...)
        if logger, ok := lg.(*logger); ok {
                logger.logger.Error(msg, fields...)
        } else {
                lg.Error(ctx, msg, args...)
        }
}

func logger.Panic

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/logger.go:

func (l *logger) Panic(ctx context.Context, format string, args ...any) {
        lg, msg, fields := l.sweeten(ctx, format, args...)
        if logger, ok := lg.(*logger); ok {
                logger.logger.Panic(msg, fields...)
        } else {
                lg.Panic(ctx, msg, args...)
        }
}

func logger.Fatal

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/logger.go:

func (l *logger) Fatal(ctx context.Context, format string, args ...any) {
        lg, msg, fields := l.sweeten(ctx, format, args...)
        if logger, ok := lg.(*logger); ok {
                logger.logger.Fatal(msg, fields...)
        } else {
                lg.Fatal(ctx, msg, args...)
        }
}

func @92:4

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/construct.go:

func() bool {
                                sum := md5.Sum([]byte(env.WorkDir))
                                logName = string(sum[:]) + ext
                                return true
                        }

func TimeElapsed

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/candy.go:

func TimeElapsed(ctx context.Context, logger Loggable, fn func(), format string, args ...any) {
        now := time.Now()
        defer func() {
                elapsed := time.Since(now).Milliseconds()
                if r := recover(); r != nil {
                        panic(r)
                }
                if logger != nil {
                        logger.Info(ctx, format, append(args, zap.Any("latency", elapsed))...)
                } else {
                        Info(ctx, format, append(args, zap.Any("latency", elapsed))...)
                }
        }()

        fn()
}

func @88:4

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/construct.go:

88	`func() bool {`
89	`logName = filepath.Base(env.WorkDir) + ext`
90	`return logName != constant.PathSeparator+".log"`
91	`}`

func Debug

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/candy.go:

14	`func Debug(ctx context.Context, format string, args ...any) { globalLogger.Debug(ctx, format, args...) }`

func GetContextFields

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/candy.go:

38	`func GetContextFields(ctx context.Context) Fields {`
39	`return utils.GetCtxAny(ctx, fusCtx.KeyLogFields, (Fields)(nil))`
40	`}`

func @157:4

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/construct.go:

157	`func() Loggable { return Use(name, AppName(opt.AppName)) }`

func SetCtxLogger

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/context.go:

39	`func SetCtxLogger(ctx context.Context, val Loggable) context.Context {`
40	`return utils.SetCtxAny(ctx, fusCtx.KeyLoggable, val)`
41	`}`

func Panic

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/candy.go:

18	`func Panic(ctx context.Context, format string, args ...any) { globalLogger.Panic(ctx, format, args...) }`

func Error

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/candy.go:

17	`func Error(ctx context.Context, format string, args ...any) { globalLogger.Error(ctx, format, args...) }`

func Warn

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/candy.go:

16	`func Warn(ctx context.Context, format string, args ...any) { globalLogger.Warn(ctx, format, args...) }`

func Fatal

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/candy.go:

19	`func Fatal(ctx context.Context, format string, args ...any) { globalLogger.Fatal(ctx, format, args...) }`

Package Overview: github.com/wfusion/gofusion/log/customlogger 59.2%

Please select a function to see what's left for testing.

`gormLogger.Init(...)`	`github.com/wfusion/gofusion/log/customlogger/gorm.go`	`100.0%`	`5/5`
`mongoLogger.Init(...)`	`github.com/wfusion/gofusion/log/customlogger/mongo.go`	`100.0%`	`5/5`
`asyncLogger.Init(...)`	`github.com/wfusion/gofusion/log/customlogger/async.go`	`100.0%`	`4/4`
`cronLogger.Init(...)`	`github.com/wfusion/gofusion/log/customlogger/cron.go`	`100.0%`	`4/4`
`metricsLogger.Init(...)`	`github.com/wfusion/gofusion/log/customlogger/metrics.go`	`100.0%`	`4/4`
`mqLogger.Debug(...)`	`github.com/wfusion/gofusion/log/customlogger/mq.go`	`100.0%`	`4/4`
`cronLogger.isLoggable(...)`	`github.com/wfusion/gofusion/log/customlogger/cron.go`	`100.0%`	`4/4`
`mqLogger.Info(...)`	`github.com/wfusion/gofusion/log/customlogger/mq.go`	`100.0%`	`4/4`
`metricsLogger.Info(...)`	`github.com/wfusion/gofusion/log/customlogger/metrics.go`	`100.0%`	`4/4`
`redisLogger.Init(...)`	`github.com/wfusion/gofusion/log/customlogger/redis.go`	`100.0%`	`4/4`
`mqLogger.isLoggable(...)`	`github.com/wfusion/gofusion/log/customlogger/mq.go`	`100.0%`	`4/4`
`metricsLogger.Warn(...)`	`github.com/wfusion/gofusion/log/customlogger/metrics.go`	`100.0%`	`4/4`
`mqLogger.Init(...)`	`github.com/wfusion/gofusion/log/customlogger/mq.go`	`100.0%`	`4/4`
`routineLogger.reloadConfig(...)`	`github.com/wfusion/gofusion/log/customlogger/routine.go`	`100.0%`	`3/3`
`mqLogger.logger(...)`	`github.com/wfusion/gofusion/log/customlogger/mq.go`	`100.0%`	`3/3`
`httpLogger.reloadConfig(...)`	`github.com/wfusion/gofusion/log/customlogger/http.go`	`100.0%`	`3/3`
`mongoLogger.succeeded(...)`	`github.com/wfusion/gofusion/log/customlogger/mongo.go`	`100.0%`	`3/3`
`mongoLogger.pushCommandString(...)`	`github.com/wfusion/gofusion/log/customlogger/mongo.go`	`100.0%`	`3/3`
`routineLogger.Init(...)`	`github.com/wfusion/gofusion/log/customlogger/routine.go`	`100.0%`	`3/3`
`cronLogger.logger(...)`	`github.com/wfusion/gofusion/log/customlogger/cron.go`	`100.0%`	`3/3`
`mongoLogger.started(...)`	`github.com/wfusion/gofusion/log/customlogger/mongo.go`	`100.0%`	`3/3`
`httpLogger.Init(...)`	`github.com/wfusion/gofusion/log/customlogger/http.go`	`100.0%`	`3/3`
`gormLogger.Info(...)`	`github.com/wfusion/gofusion/log/customlogger/gorm.go`	`100.0%`	`2/2`
`mongoLogger.fields(...)`	`github.com/wfusion/gofusion/log/customlogger/mongo.go`	`100.0%`	`1/1`
`redisLogger.ProcessPipelineHook(...)`	`github.com/wfusion/gofusion/log/customlogger/redis.go`	`100.0%`	`1/1`
`mqLogger.With(...)`	`github.com/wfusion/gofusion/log/customlogger/mq.go`	`100.0%`	`1/1`
`mongoLogger.GetMonitor(...)`	`github.com/wfusion/gofusion/log/customlogger/mongo.go`	`100.0%`	`1/1`
`DefaultCronLogger(...)`	`github.com/wfusion/gofusion/log/customlogger/cron.go`	`100.0%`	`1/1`
`gormLogger.format(...)`	`github.com/wfusion/gofusion/log/customlogger/gorm.go`	`100.0%`	`1/1`
`gormLogger.fields(...)`	`github.com/wfusion/gofusion/log/customlogger/gorm.go`	`100.0%`	`1/1`
`redisLogger.DialHook(...)`	`github.com/wfusion/gofusion/log/customlogger/redis.go`	`100.0%`	`1/1`
`@41:9(...)`	`github.com/wfusion/gofusion/log/customlogger/redis.go`	`100.0%`	`1/1`
`redisLogger.ProcessHook(...)`	`github.com/wfusion/gofusion/log/customlogger/redis.go`	`100.0%`	`1/1`
`redisLogger.fields(...)`	`github.com/wfusion/gofusion/log/customlogger/redis.go`	`100.0%`	`1/1`
`mongoLogger.popCommandString(...)`	`github.com/wfusion/gofusion/log/customlogger/mongo.go`	`85.7%`	`6/7`
`redisLogger.reloadConfig(...)`	`github.com/wfusion/gofusion/log/customlogger/redis.go`	`80.0%`	`12/15`
`mqLogger.parseLogFields(...)`	`github.com/wfusion/gofusion/log/customlogger/mq.go`	`80.0%`	`8/10`
`mongoLogger.isLoggableCommandName(...)`	`github.com/wfusion/gofusion/log/customlogger/mongo.go`	`80.0%`	`4/5`
`gormLogger.reloadConfig(...)`	`github.com/wfusion/gofusion/log/customlogger/gorm.go`	`78.6%`	`11/14`
`metricsLogger.reloadConfig(...)`	`github.com/wfusion/gofusion/log/customlogger/metrics.go`	`77.8%`	`7/9`
`cronLogger.reloadConfig(...)`	`github.com/wfusion/gofusion/log/customlogger/cron.go`	`77.8%`	`7/9`
`asyncLogger.reloadConfig(...)`	`github.com/wfusion/gofusion/log/customlogger/async.go`	`77.8%`	`7/9`
`mqLogger.reloadConfig(...)`	`github.com/wfusion/gofusion/log/customlogger/mq.go`	`77.8%`	`7/9`
`mongoLogger.reloadConfig(...)`	`github.com/wfusion/gofusion/log/customlogger/mongo.go`	`75.0%`	`12/16`
`redisLogger.isLoggableCommandSet(...)`	`github.com/wfusion/gofusion/log/customlogger/redis.go`	`75.0%`	`6/8`
`@45:9(...)`	`github.com/wfusion/gofusion/log/customlogger/redis.go`	`75.0%`	`6/8`
`cronLogger.Debug(...)`	`github.com/wfusion/gofusion/log/customlogger/cron.go`	`75.0%`	`3/4`
`asyncLogger.isLoggable(...)`	`github.com/wfusion/gofusion/log/customlogger/async.go`	`75.0%`	`3/4`
`cronLogger.Info(...)`	`github.com/wfusion/gofusion/log/customlogger/cron.go`	`75.0%`	`3/4`
`cronLogger.Warn(...)`	`github.com/wfusion/gofusion/log/customlogger/cron.go`	`75.0%`	`3/4`
`asyncLogger.Info(...)`	`github.com/wfusion/gofusion/log/customlogger/async.go`	`75.0%`	`3/4`
`mqLogger.Trace(...)`	`github.com/wfusion/gofusion/log/customlogger/mq.go`	`75.0%`	`3/4`
`gormLogger.isLoggable(...)`	`github.com/wfusion/gofusion/log/customlogger/gorm.go`	`75.0%`	`3/4`
`metricsLogger.Debug(...)`	`github.com/wfusion/gofusion/log/customlogger/metrics.go`	`75.0%`	`3/4`
`metricsLogger.isLoggable(...)`	`github.com/wfusion/gofusion/log/customlogger/metrics.go`	`75.0%`	`3/4`
`redisLogger.isLoggable(...)`	`github.com/wfusion/gofusion/log/customlogger/redis.go`	`75.0%`	`3/4`
`mongoLogger.logger(...)`	`github.com/wfusion/gofusion/log/customlogger/mongo.go`	`66.7%`	`2/3`
`metricsLogger.logger(...)`	`github.com/wfusion/gofusion/log/customlogger/metrics.go`	`66.7%`	`2/3`
`mongoLogger.failed(...)`	`github.com/wfusion/gofusion/log/customlogger/mongo.go`	`66.7%`	`2/3`
`cronLogger.Printf(...)`	`github.com/wfusion/gofusion/log/customlogger/cron.go`	`66.7%`	`2/3`
`redisLogger.logger(...)`	`github.com/wfusion/gofusion/log/customlogger/redis.go`	`66.7%`	`2/3`
`gormLogger.logger(...)`	`github.com/wfusion/gofusion/log/customlogger/gorm.go`	`66.7%`	`2/3`
`asyncLogger.logger(...)`	`github.com/wfusion/gofusion/log/customlogger/async.go`	`66.7%`	`2/3`
`cronLogger.parseArgs(...)`	`github.com/wfusion/gofusion/log/customlogger/cron.go`	`63.6%`	`14/22`
`asyncLogger.parseArgs(...)`	`github.com/wfusion/gofusion/log/customlogger/async.go`	`63.6%`	`14/22`
`metricsLogger.parseArgs(...)`	`github.com/wfusion/gofusion/log/customlogger/metrics.go`	`54.5%`	`12/22`
`gormLogger.Trace(...)`	`github.com/wfusion/gofusion/log/customlogger/gorm.go`	`47.6%`	`10/21`
`gormLogger.getLogLevel(...)`	`github.com/wfusion/gofusion/log/customlogger/gorm.go`	`33.3%`	`2/6`
`httpLogger.Debugf(...)`	`github.com/wfusion/gofusion/log/customlogger/http.go`	`33.3%`	`1/3`
`httpLogger.Errorf(...)`	`github.com/wfusion/gofusion/log/customlogger/http.go`	`33.3%`	`1/3`
`@64:9(...)`	`github.com/wfusion/gofusion/log/customlogger/redis.go`	`18.2%`	`2/11`
`httpLogger.parseArgs(...)`	`github.com/wfusion/gofusion/log/customlogger/http.go`	`0.0%`	`0/14`
`routineLogger.parseArgs(...)`	`github.com/wfusion/gofusion/log/customlogger/routine.go`	`0.0%`	`0/14`
`mqLogger.Error(...)`	`github.com/wfusion/gofusion/log/customlogger/mq.go`	`0.0%`	`0/6`
`asyncLogger.Debug(...)`	`github.com/wfusion/gofusion/log/customlogger/async.go`	`0.0%`	`0/4`
`asyncLogger.Warn(...)`	`github.com/wfusion/gofusion/log/customlogger/async.go`	`0.0%`	`0/4`
`cronLogger.Error(...)`	`github.com/wfusion/gofusion/log/customlogger/cron.go`	`0.0%`	`0/4`
`asyncLogger.Error(...)`	`github.com/wfusion/gofusion/log/customlogger/async.go`	`0.0%`	`0/4`
`metricsLogger.Fatal(...)`	`github.com/wfusion/gofusion/log/customlogger/metrics.go`	`0.0%`	`0/4`
`cronLogger.Fatal(...)`	`github.com/wfusion/gofusion/log/customlogger/cron.go`	`0.0%`	`0/4`
`asyncLogger.Fatal(...)`	`github.com/wfusion/gofusion/log/customlogger/async.go`	`0.0%`	`0/4`
`metricsLogger.Error(...)`	`github.com/wfusion/gofusion/log/customlogger/metrics.go`	`0.0%`	`0/4`
`httpLogger.Warnf(...)`	`github.com/wfusion/gofusion/log/customlogger/http.go`	`0.0%`	`0/3`
`metricsLogger.Printf(...)`	`github.com/wfusion/gofusion/log/customlogger/metrics.go`	`0.0%`	`0/3`
`DefaultMongoLogger(...)`	`github.com/wfusion/gofusion/log/customlogger/mongo.go`	`0.0%`	`0/3`
`httpLogger.logger(...)`	`github.com/wfusion/gofusion/log/customlogger/http.go`	`0.0%`	`0/3`
`routineLogger.Printf(...)`	`github.com/wfusion/gofusion/log/customlogger/routine.go`	`0.0%`	`0/3`
`asyncLogger.Printf(...)`	`github.com/wfusion/gofusion/log/customlogger/async.go`	`0.0%`	`0/3`
`routineLogger.logger(...)`	`github.com/wfusion/gofusion/log/customlogger/routine.go`	`0.0%`	`0/3`
`gormLogger.Error(...)`	`github.com/wfusion/gofusion/log/customlogger/gorm.go`	`0.0%`	`0/2`
`gormLogger.LogMode(...)`	`github.com/wfusion/gofusion/log/customlogger/gorm.go`	`0.0%`	`0/2`
`gormLogger.Warn(...)`	`github.com/wfusion/gofusion/log/customlogger/gorm.go`	`0.0%`	`0/2`
`DefaultHttpLogger(...)`	`github.com/wfusion/gofusion/log/customlogger/http.go`	`0.0%`	`0/1`
`DefaultRoutineLogger(...)`	`github.com/wfusion/gofusion/log/customlogger/routine.go`	`0.0%`	`0/1`
`DefaultAsyncLogger(...)`	`github.com/wfusion/gofusion/log/customlogger/async.go`	`0.0%`	`0/1`
`DefaultAsynqAsyncLogger(...)`	`github.com/wfusion/gofusion/log/customlogger/async.go`	`0.0%`	`0/1`
`DefaultMySQLLogger(...)`	`github.com/wfusion/gofusion/log/customlogger/gorm.go`	`0.0%`	`0/1`
`NewLogger(...)`	`github.com/wfusion/gofusion/log/customlogger/mq.go`	`0.0%`	`0/1`
`DefaultAsynqCronLogger(...)`	`github.com/wfusion/gofusion/log/customlogger/cron.go`	`0.0%`	`0/1`
`DefaultMetricsLogger(...)`	`github.com/wfusion/gofusion/log/customlogger/metrics.go`	`0.0%`	`0/1`

func gormLogger.Init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/gorm.go:

func (g *gormLogger) Init(log log.Loggable, appName, name string) {
        g.log = log
        g.appName = appName
        g.confName = name
        g.ignoreRecordNotFoundError = true
        g.reloadConfig()
}

func mongoLogger.Init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/mongo.go:

func (m *mongoLogger) Init(log log.Loggable, appName, name string) {
        m.log = log
        m.appName = appName
        m.confName = name
        m.requestMap = make(map[int64]struct{ commandString string })
        m.loggableCommandSet = utils.NewSet[string](
                "ping",
                "insert",
                "find",
                "update",
                "delete",
                "aggregate",
                "distinct",
                "count",
                "findAndModify",
                "getMore",
                "killCursors",
                "create",
                "drop",
                "listDatabases",
                "dropDatabase",
                "createIndexes",
                "listIndexes",
                "dropIndexes",
                "listCollections",
        )
}

func asyncLogger.Init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/async.go:

func (a *asyncLogger) Init(log log.Loggable, appName, confName string) {
        a.log = log
        a.appName = appName
        a.confName = confName
        a.reloadConfig()
}

func cronLogger.Init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/cron.go:

func (c *cronLogger) Init(log log.Loggable, appName, name string) {
        c.log = log
        c.appName = appName
        c.confName = name
        c.reloadConfig()
}

func metricsLogger.Init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/metrics.go:

func (m *metricsLogger) Init(log log.Loggable, appName, name string) {
        m.log = log
        m.appName = appName
        m.confName = name
        m.reloadConfig()
}

func mqLogger.Debug

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/mq.go:

func (m *mqLogger) Debug(msg string, fields watermill.LogFields) {
        if !m.isLoggable() {
                return
        }
        ctx, fs := m.parseLogFields(fields)
        m.logger().Debug(ctx, msg, fs)
}

func cronLogger.isLoggable

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/cron.go:

func (c *cronLogger) isLoggable() bool {
        if c.confName == "" {
                return true
        }
        c.reloadConfig()
        return c.enabled
}

func mqLogger.Info

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/mq.go:

func (m *mqLogger) Info(msg string, fields watermill.LogFields) {
        if !m.isLoggable() {
                return
        }
        ctx, fs := m.parseLogFields(fields)
        m.logger().Info(ctx, msg, fs)
}

func metricsLogger.Info

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/metrics.go:

func (m *metricsLogger) Info(args ...any) {
        if !m.isLoggable() {
                return
        }
        ctx, format, args := m.parseArgs(args...)
        m.logger().Info(ctx, format, args...)
}

func redisLogger.Init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/redis.go:

func (r *redisLogger) Init(log log.Loggable, appName, name string) {
        r.log = log
        r.appName = appName
        r.confName = name
        r.reloadConfig()
}

func mqLogger.isLoggable

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/mq.go:

func (m *mqLogger) isLoggable() bool {
        if m.confName == "" {
                return true
        }

        m.reloadConfig()
        return m.enabled
}

func metricsLogger.Warn

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/metrics.go:

func (m *metricsLogger) Warn(args ...any) {
        if !m.isLoggable() {
                return
        }
        ctx, format, args := m.parseArgs(args...)
        m.logger().Warn(ctx, format, args...)
}

func mqLogger.Init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/mq.go:

func (m *mqLogger) Init(log log.Loggable, appName, name string) {
        m.log = log
        m.appName = appName
        m.confName = name
        m.reloadConfig()
}

func routineLogger.reloadConfig

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/routine.go:

func (r *routineLogger) reloadConfig() {
        cfg := make(map[string]any)
        _ = config.Use(r.appName).LoadComponentConfig(config.ComponentGoroutinePool, &cfg)

        r.enabled = cast.ToBool(cfg["enable_logger"])
}

func mqLogger.logger

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/mq.go:

func (m *mqLogger) logger() log.Loggable {
        if m.log != nil {
                return m.log
        }
        return log.Use(config.DefaultInstanceKey, log.AppName(m.appName))
}

func httpLogger.reloadConfig

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/http.go:

func (h *httpLogger) reloadConfig() {
        cfg := make(map[string]any)
        _ = config.Use(h.appName).LoadComponentConfig(config.ComponentHttp, &cfg)

        h.enabled = cast.ToBool(cfg["enable_logger"])
}

func mongoLogger.succeeded

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/mongo.go:

func (m *mongoLogger) succeeded(ctx context.Context, evt *event.CommandSucceededEvent) {
        if !m.isLoggableCommandName(evt.CommandName) {
                return
        }
        m.logger().Info(ctx, "%s succeeded: %s [request[%v] command[%s]]",
                evt.CommandName, evt.Reply, evt.RequestID, m.popCommandString(evt.RequestID),
                m.fields(log.Fields{"latency": int64(evt.Duration) / int64(time.Millisecond)}))
}

func mongoLogger.pushCommandString

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/mongo.go:

func (m *mongoLogger) pushCommandString(requestID int64, commandString string) {
        m.mutex.Lock()
        defer m.mutex.Unlock()
        m.requestMap[requestID] = struct{ commandString string }{commandString: commandString}
}

func routineLogger.Init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/routine.go:

func (r *routineLogger) Init(log log.Loggable, appName string) {
        r.log = log
        r.appName = appName
        r.reloadConfig()
}

func cronLogger.logger

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/cron.go:

func (c *cronLogger) logger() log.Loggable {
        if c.log != nil {
                return c.log
        }
        return log.Use(config.DefaultInstanceKey, log.AppName(c.appName))
}

func mongoLogger.started

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/mongo.go:

func (m *mongoLogger) started(ctx context.Context, evt *event.CommandStartedEvent) {
        if !m.isLoggableCommandName(evt.CommandName) {
                return
        }
        m.pushCommandString(evt.RequestID, evt.Command.String())
}

func httpLogger.Init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/http.go:

func (h *httpLogger) Init(log log.Loggable, appName string) {
        h.log = log
        h.appName = appName
        h.reloadConfig()
}

func gormLogger.Info

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/gorm.go:

func (g *gormLogger) Info(ctx context.Context, msg string, data ...any) {
        if g.isLoggable() && g.logLevel >= logger.Info {
                g.logger().Info(ctx, msg, append(data, dbFields)...)
        }
}

func mongoLogger.fields

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/mongo.go:

161	`func (m *mongoLogger) fields(fields log.Fields) log.Fields {`
162	`return utils.MapMerge(fields, mongoFields)`
163	`}`

func redisLogger.ProcessPipelineHook

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/redis.go:

func (r *redisLogger) ProcessPipelineHook(next rdsDrv.ProcessPipelineHook) rdsDrv.ProcessPipelineHook {
        return func(ctx context.Context, cmds []rdsDrv.Cmder) (err error) {
                if !r.isLoggable() {
                        return next(ctx, cmds)
                }
                begin := time.Now()
                fullNameSb := new(strings.Builder)
                for _, cmd := range cmds {
                        _, _ = fullNameSb.WriteString(cmd.FullName() + " -> ")
                }

                if err = next(ctx, cmds); err != nil {
                        r.logger().Warn(ctx, "%s failed", fullNameSb.String(),
                                r.fields(log.Fields{"latency": time.Since(begin).Milliseconds()}))
                        return
                }

                r.logger().Info(ctx, "%s succeeded", fullNameSb.String(),
                        r.fields(log.Fields{"latency": time.Since(begin).Milliseconds()}))
                return
        }
}

func mqLogger.With

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/mq.go:

84	`func (m *mqLogger) With(fields watermill.LogFields) watermill.LoggerAdapter {`
85	`return &mqLogger{fields: m.fields.Add(fields)}`
86	`}`

func mongoLogger.GetMonitor

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/mongo.go:

func (m *mongoLogger) GetMonitor() *event.CommandMonitor {
        return &event.CommandMonitor{
                Started:   m.started,
                Succeeded: m.succeeded,
                Failed:    m.failed,
        }
}

func DefaultCronLogger

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/cron.go:

21	`func DefaultCronLogger() interface{ Printf(string, ...any) } {`
22	`return &cronLogger{}`
23	`}`

func gormLogger.format

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/gorm.go:

127	`func (g *gormLogger) format(sql string) string {`
128	`return strings.ReplaceAll(sql, "%", "%%")`
129	`}`

func gormLogger.fields

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/gorm.go:

131	`func (g *gormLogger) fields(fields log.Fields) log.Fields {`
132	`return utils.MapMerge(fields, dbFields)`
133	`}`

func redisLogger.DialHook

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/redis.go:

40	`func (r *redisLogger) DialHook(next rdsDrv.DialHook) rdsDrv.DialHook {`
41	`return func(ctx context.Context, network, addr string) (c net.Conn, e error) { return next(ctx, network, addr) }`
42	`}`

func @41:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/redis.go:

41	`func(ctx context.Context, network, addr string) (c net.Conn, e error) { return next(ctx, network, addr) }`

func redisLogger.ProcessHook

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/redis.go:

func (r *redisLogger) ProcessHook(next rdsDrv.ProcessHook) rdsDrv.ProcessHook {
        return func(ctx context.Context, cmd rdsDrv.Cmder) (err error) {
                if !r.isLoggableCommandSet(cmd.Name()) {
                        return next(ctx, cmd)
                }

                begin := time.Now()
                if err = next(ctx, cmd); err != nil {
                        r.logger().Warn(ctx, "%s failed [command[%s]]", cmd.FullName(), cmd.String(),
                                r.fields(log.Fields{"latency": time.Since(begin).Milliseconds()}))
                        return
                }

                r.logger().Info(ctx, "%s succeeded [command[%s]]", cmd.FullName(), cmd.String(),
                        r.fields(log.Fields{"latency": time.Since(begin).Milliseconds()}))
                return
        }
}

func redisLogger.fields

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/redis.go:

93	`func (r *redisLogger) fields(fields log.Fields) log.Fields {`
94	`return utils.MapMerge(fields, redisFields)`
95	`}`

func mongoLogger.popCommandString

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/mongo.go:

func (m *mongoLogger) popCommandString(requestID int64) string {
        m.mutex.Lock()
        defer m.mutex.Unlock()
        reqCtx, ok := m.requestMap[requestID]
        if ok {
                delete(m.requestMap, requestID)
                return reqCtx.commandString
        }
        return ""
}

func redisLogger.reloadConfig

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/redis.go:

func (r *redisLogger) reloadConfig() {
        var cfgs map[string]map[string]any
        _ = config.Use(r.appName).LoadComponentConfig(config.ComponentRedis, &cfgs)
        if len(cfgs) == 0 {
                return
        }

        cfg, ok := cfgs[r.confName]
        if !ok {
                return
        }
        enabled := cast.ToBool(cfg["enable_logger"])
        r.enabled = enabled

        unloggableCommandsObj, ok1 := cfg["unloggable_commands"]
        unloggableCommands, ok2 := unloggableCommandsObj.([]string)
        if !ok1 || !ok2 {
                return
        }
        sets := utils.NewSet(unloggableCommands...)
        r.unloggableCommandSet = sets
}

func mqLogger.parseLogFields

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/mq.go:

func (m *mqLogger) parseLogFields(fields watermill.LogFields) (ctx context.Context, fs log.Fields) {
        ctx = context.Background()
        fields = m.fields.Add(fields)

        fs = make(log.Fields, len(fields)+1)
        for k, v := range fields {
                if k == watermill.ContextLogFieldKey {
                        ctx = v.(context.Context)
                        continue
                }
                fs[k] = v
        }
        fs = utils.MapMerge(fs, mqFields)
        return
}

func mongoLogger.isLoggableCommandName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/mongo.go:

func (m *mongoLogger) isLoggableCommandName(commandName string) bool {
        if m.confName == "" {
                return true
        }
        if m.reloadConfig(); !m.enabled {
                return false
        }
        return m.loggableCommandSet.Contains(commandName)
}

func gormLogger.reloadConfig

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/gorm.go:

func (g *gormLogger) reloadConfig() {
        var cfgs map[string]map[string]any
        _ = config.Use(g.appName).LoadComponentConfig(config.ComponentDB, &cfgs)
        if len(cfgs) == 0 {
                return
        }

        cfg, ok := cfgs[g.confName]
        if !ok {
                return
        }
        g.enabled = cast.ToBool(cfg["enable_logger"])
        logConfigObj, ok1 := cfg["logger_config"]
        logCfg, ok2 := logConfigObj.(map[string]any)
        if !ok1 || !ok2 {
                return
        }
        g.logLevel = g.getLogLevel(cast.ToString(logCfg["log_level"]))
        g.slowThreshold, _ = time.ParseDuration(cast.ToString(logCfg["slow_threshold"]))
}

func metricsLogger.reloadConfig

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/metrics.go:

func (m *metricsLogger) reloadConfig() {
        var cfgs map[string]map[string]any
        _ = config.Use(m.appName).LoadComponentConfig(config.ComponentMetrics, &cfgs)
        if len(cfgs) == 0 {
                return
        }

        cfg, ok := cfgs[m.confName]
        if !ok {
                return
        }
        enabled := cast.ToBool(cfg["enable_logger"])
        m.enabled = enabled
}

func cronLogger.reloadConfig

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/cron.go:

func (c *cronLogger) reloadConfig() {
        var cfgs map[string]map[string]any
        _ = config.Use(c.appName).LoadComponentConfig(config.ComponentCron, &cfgs)
        if len(cfgs) == 0 {
                return
        }

        cfg, ok := cfgs[c.confName]
        if !ok {
                return
        }
        enabled := cast.ToBool(cfg["enable_logger"])
        c.enabled = enabled
}

func asyncLogger.reloadConfig

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/async.go:

func (a *asyncLogger) reloadConfig() {
        var cfgs map[string]map[string]any
        _ = config.Use(a.appName).LoadComponentConfig(config.ComponentAsync, &cfgs)
        if len(cfgs) == 0 {
                return
        }

        cfg, ok := cfgs[a.confName]
        if !ok {
                return
        }
        enabled := cast.ToBool(cfg["enable_logger"])
        a.enabled = enabled
}

func mqLogger.reloadConfig

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/mq.go:

func (m *mqLogger) reloadConfig() {
        var cfgs map[string]map[string]any
        _ = config.Use(m.appName).LoadComponentConfig(config.ComponentMessageQueue, &cfgs)
        if len(cfgs) == 0 {
                return
        }

        cfg, ok := cfgs[m.confName]
        if !ok {
                return
        }
        enabled := cast.ToBool(cfg["enable_logger"])
        m.enabled = enabled
}

func mongoLogger.reloadConfig

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/mongo.go:

func (m *mongoLogger) reloadConfig() {
        var cfgs map[string]map[string]any
        _ = config.Use(m.appName).LoadComponentConfig(config.ComponentMongo, &cfgs)
        if len(cfgs) == 0 {
                return
        }

        cfg, ok := cfgs[m.confName]
        if !ok {
                return
        }
        m.enabled = cast.ToBool(cfg["enable_logger"])
        logConfigObj, ok1 := cfg["logger_config"]
        logCfg, ok2 := logConfigObj.(map[string]any)
        if !ok1 || !ok2 {
                return
        }
        loggableCommandList, ok := logCfg["loggable_commands"].([]string)
        if !ok {
                return
        }

        m.loggableCommandSet = utils.NewSet(loggableCommandList...)
}

func redisLogger.isLoggableCommandSet

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/redis.go:

func (r *redisLogger) isLoggableCommandSet(command string) bool {
        if r.confName == "" {
                return true
        }

        r.reloadConfig()
        if !r.enabled {
                return false
        }
        if r.unloggableCommandSet == nil {
                return true
        }
        return !r.unloggableCommandSet.Contains(command)
}

func @45:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/redis.go:

func(ctx context.Context, cmd rdsDrv.Cmder) (err error) {
                if !r.isLoggableCommandSet(cmd.Name()) {
                        return next(ctx, cmd)
                }

                begin := time.Now()
                if err = next(ctx, cmd); err != nil {
                        r.logger().Warn(ctx, "%s failed [command[%s]]", cmd.FullName(), cmd.String(),
                                r.fields(log.Fields{"latency": time.Since(begin).Milliseconds()}))
                        return
                }

                r.logger().Info(ctx, "%s succeeded [command[%s]]", cmd.FullName(), cmd.String(),
                        r.fields(log.Fields{"latency": time.Since(begin).Milliseconds()}))
                return
        }

func cronLogger.Debug

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/cron.go:

func (c *cronLogger) Debug(args ...any) {
        if !c.isLoggable() {
                return
        }
        ctx, format, args := c.parseArgs(args...)
        c.logger().Debug(ctx, format, args...)
}

func asyncLogger.isLoggable

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/async.go:

func (a *asyncLogger) isLoggable() bool {
        if a.confName == "" {
                return true
        }
        a.reloadConfig()
        return a.enabled
}

func cronLogger.Info

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/cron.go:

func (c *cronLogger) Info(args ...any) {
        if !c.isLoggable() {
                return
        }
        ctx, format, args := c.parseArgs(args...)
        c.logger().Info(ctx, format, args...)
}

func cronLogger.Warn

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/cron.go:

func (c *cronLogger) Warn(args ...any) {
        if !c.isLoggable() {
                return
        }
        ctx, format, args := c.parseArgs(args...)
        c.logger().Warn(ctx, format, args...)
}

func asyncLogger.Info

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/async.go:

func (a *asyncLogger) Info(args ...any) {
        if !a.isLoggable() {
                return
        }
        ctx, format, args := a.parseArgs(args...)
        a.logger().Info(ctx, format, args...)
}

func mqLogger.Trace

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/mq.go:

func (m *mqLogger) Trace(msg string, fields watermill.LogFields) {
        if !m.isLoggable() {
                return
        }
        ctx, fs := m.parseLogFields(fields)
        m.logger().Debug(ctx, msg, fs)
}

func gormLogger.isLoggable

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/gorm.go:

func (g *gormLogger) isLoggable() bool {
        if g.confName == "" {
                return true
        }
        g.reloadConfig()
        return g.enabled
}

func metricsLogger.Debug

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/metrics.go:

func (m *metricsLogger) Debug(args ...any) {
        if !m.isLoggable() {
                return
        }
        ctx, format, args := m.parseArgs(args...)
        m.logger().Debug(ctx, format, args...)
}

func metricsLogger.isLoggable

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/metrics.go:

func (m *metricsLogger) isLoggable() bool {
        if m.confName == "" {
                return true
        }
        m.reloadConfig()
        return m.enabled
}

func redisLogger.isLoggable

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/redis.go:

func (r *redisLogger) isLoggable() bool {
        if r.confName == "" {
                return true
        }
        r.reloadConfig()
        return r.enabled
}

func mongoLogger.logger

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/mongo.go:

func (m *mongoLogger) logger() log.Loggable {
        if m.log != nil {
                return m.log
        }
        return log.Use(config.DefaultInstanceKey, log.AppName(m.appName))
}

func metricsLogger.logger

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/metrics.go:

func (m *metricsLogger) logger() log.Loggable {
        if m.log != nil {
                return m.log
        }
        return log.Use(config.DefaultInstanceKey, log.AppName(m.appName))
}

func mongoLogger.failed

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/mongo.go:

func (m *mongoLogger) failed(ctx context.Context, evt *event.CommandFailedEvent) {
        if !m.isLoggableCommandName(evt.CommandName) {
                return
        }

        m.logger().Warn(ctx, "%s failed: %s [request[%v] command[%s]]",
                evt.CommandName, evt.Failure, evt.RequestID, m.popCommandString(evt.RequestID),
                m.fields(log.Fields{"latency": int64(evt.Duration) / int64(time.Millisecond)}))
}

func cronLogger.Printf

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/cron.go:

func (c *cronLogger) Printf(format string, args ...any) {
        if !c.isLoggable() {
                return
        }
        c.logger().Info(context.Background(), format, append(args, cronFields)...)
}

func redisLogger.logger

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/redis.go:

func (r *redisLogger) logger() log.Loggable {
        if r.log != nil {
                return r.log
        }
        return log.Use(config.DefaultInstanceKey, log.AppName(r.appName))
}

func gormLogger.logger

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/gorm.go:

func (g *gormLogger) logger() log.Loggable {
        if g.log != nil {
                return g.log
        }
        return log.Use(config.DefaultInstanceKey, log.AppName(g.appName))
}

func asyncLogger.logger

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/async.go:

func (a *asyncLogger) logger() log.Loggable {
        if a.log != nil {
                return a.log
        }
        return log.Use(config.DefaultInstanceKey, log.AppName(a.appName))
}

func cronLogger.parseArgs

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/cron.go:

func (c *cronLogger) parseArgs(args ...any) (ctx context.Context, format string, params []any) {
        var ok bool

        if len(args) == 0 {
                return context.Background(), "", []any{cronFields}
        }
        if len(args) == 1 {
                args = append(args, cronFields)
                return context.Background(), "%+v", args
        }

        format, ok = args[0].(string)
        if ok {
                params = args[1:]
        } else {
                ctx, _ = args[0].(context.Context)
                format, _ = args[1].(string)
                params = args[2:]
        }
        if format == "" {
                placeholder := make([]string, len(args))
                for i := 0; i < len(args); i++ {
                        placeholder[i] = "%+v"
                }
                format = strings.Join(placeholder, " ")
                params = args
        }

        if ctx == nil {
                ctx = context.Background()
        }

        params = append(params, cronFields)
        return
}

func asyncLogger.parseArgs

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/async.go:

func (a *asyncLogger) parseArgs(args ...any) (ctx context.Context, format string, params []any) {
        var ok bool

        if len(args) == 0 {
                return context.Background(), "", []any{asyncFields}
        }
        if len(args) == 1 {
                args = append(args, asyncFields)
                return context.Background(), "%+v", args
        }

        format, ok = args[0].(string)
        if ok {
                params = args[1:]
        } else {
                ctx, _ = args[0].(context.Context)
                format, _ = args[1].(string)
                params = args[2:]
        }
        if format == "" {
                placeholder := make([]string, len(args))
                for i := 0; i < len(args); i++ {
                        placeholder[i] = "%+v"
                }
                format = strings.Join(placeholder, " ")
                params = args
        }

        if ctx == nil {
                ctx = context.Background()
        }

        params = append(params, asyncFields)
        return
}

func metricsLogger.parseArgs

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/metrics.go:

func (m *metricsLogger) parseArgs(args ...any) (ctx context.Context, format string, params []any) {
        var ok bool

        if len(args) == 0 {
                return context.Background(), "", []any{metricsFields}
        }
        if len(args) == 1 {
                args = append(args, metricsFields)
                return context.Background(), "%+v", args
        }

        format, ok = args[0].(string)
        if ok {
                params = args[1:]
        } else {
                ctx, _ = args[0].(context.Context)
                format, _ = args[1].(string)
                params = args[2:]
        }
        if format == "" {
                placeholder := make([]string, len(args))
                for i := 0; i < len(args); i++ {
                        placeholder[i] = "%+v"
                }
                format = strings.Join(placeholder, " ")
                params = args
        }

        if ctx == nil {
                ctx = context.Background()
        }

        params = append(params, metricsFields)
        return
}

func gormLogger.Trace

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/gorm.go:

func (g *gormLogger) Trace(ctx context.Context, begin time.Time, fc func() (string, int64), err error) {
        if !g.isLoggable() {
                return
        }
        if g.logLevel <= logger.Silent {
                return
        }

        elapsed := time.Since(begin)
        switch {
        case err != nil && g.logLevel >= logger.Error &&
                (!errors.Is(err, gorm.ErrRecordNotFound) || !g.ignoreRecordNotFoundError):
                sql, rows := fc()
                sql = fmt.Sprintf("err[%%s] %s", sql)
                if rows == -1 {
                        g.logger().Info(ctx, sql, err.Error(), g.fields(log.Fields{"latency": elapsed.Milliseconds()}))
                } else {
                        g.logger().Info(ctx, sql, err.Error(),
                                g.fields(log.Fields{"rows": rows, "latency": elapsed.Milliseconds()}))
                }
        case elapsed > g.slowThreshold && g.slowThreshold != 0 && g.logLevel >= logger.Warn:
                sql, rows := fc()
                slowLog := fmt.Sprintf("SLOW SQL >= %v %s", g.slowThreshold, g.format(sql))
                if rows == -1 {
                        g.logger().Info(ctx, slowLog, g.fields(log.Fields{"latency": elapsed.Milliseconds()}))
                } else {
                        g.logger().Info(ctx, slowLog, g.fields(log.Fields{"rows": rows, "latency": elapsed.Milliseconds()}))
                }
        case g.logLevel == logger.Info:
                sql, rows := fc()
                sql = g.format(sql)
                if rows == -1 {
                        g.logger().Info(ctx, sql, g.fields(log.Fields{"latency": elapsed.Milliseconds()}))
                } else {
                        g.logger().Info(ctx, sql, g.fields(log.Fields{"rows": rows, "latency": elapsed.Milliseconds()}))
                }
        }
}

func gormLogger.getLogLevel

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/gorm.go:

func (g *gormLogger) getLogLevel(level string) logger.LogLevel {
        switch strings.ToLower(level) {
        case "debug":
                return logger.Info
        case "info":
                return logger.Info
        case "warn":
                return logger.Warn
        case "error":
                return logger.Error
        default:
                return g.logLevel
        }
}

func httpLogger.Debugf

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/http.go:

func (h *httpLogger) Debugf(format string, v ...any) {
        if h.reloadConfig(); h.enabled {
                ctx, args := h.parseArgs(v...)
                h.logger().Debug(ctx, format, args...)
        }
}

func httpLogger.Errorf

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/http.go:

func (h *httpLogger) Errorf(format string, v ...any) {
        if h.reloadConfig(); h.enabled {
                ctx, args := h.parseArgs(v...)
                h.logger().Error(ctx, format, args...)
        }
}

func @64:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/redis.go:

func(ctx context.Context, cmds []rdsDrv.Cmder) (err error) {
                if !r.isLoggable() {
                        return next(ctx, cmds)
                }
                begin := time.Now()
                fullNameSb := new(strings.Builder)
                for _, cmd := range cmds {
                        _, _ = fullNameSb.WriteString(cmd.FullName() + " -> ")
                }

                if err = next(ctx, cmds); err != nil {
                        r.logger().Warn(ctx, "%s failed", fullNameSb.String(),
                                r.fields(log.Fields{"latency": time.Since(begin).Milliseconds()}))
                        return
                }

                r.logger().Info(ctx, "%s succeeded", fullNameSb.String(),
                        r.fields(log.Fields{"latency": time.Since(begin).Milliseconds()}))
                return
        }

func httpLogger.parseArgs

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/http.go:

func (h *httpLogger) parseArgs(args ...any) (ctx context.Context, params []any) {
        var ok bool

        if len(args) == 0 {
                return context.Background(), []any{httpFields}
        }
        if len(args) == 1 {
                args = append(args, httpFields)
                return context.Background(), args
        }

        params = args
        ctx, ok = args[0].(context.Context)
        if ok {
                params = args[1:]
        }

        if ctx == nil {
                ctx = context.Background()
        }

        params = append(params, httpFields)
        return
}

func routineLogger.parseArgs

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/routine.go:

func (r *routineLogger) parseArgs(args ...any) (ctx context.Context, params []any) {
        var ok bool

        if len(args) == 0 {
                return context.Background(), []any{routineFields}
        }
        if len(args) == 1 {
                args = append(args, routineFields)
                return context.Background(), args
        }

        params = args
        ctx, ok = args[0].(context.Context)
        if ok {
                params = args[1:]
        }

        if ctx == nil {
                ctx = context.Background()
        }

        params = append(params, routineFields)
        return
}

func mqLogger.Error

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/mq.go:

func (m *mqLogger) Error(msg string, err error, fields watermill.LogFields) {
        if !m.isLoggable() {
                return
        }
        ctx, fs := m.parseLogFields(fields)
        if err != nil {
                m.logger().Error(ctx, msg+": %s", err, fs)
        } else {
                m.logger().Error(ctx, msg, err, fs)
        }
}

func asyncLogger.Debug

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/async.go:

func (a *asyncLogger) Debug(args ...any) {
        if !a.isLoggable() {
                return
        }
        ctx, format, args := a.parseArgs(args...)
        a.logger().Debug(ctx, format, args...)
}

func asyncLogger.Warn

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/async.go:

func (a *asyncLogger) Warn(args ...any) {
        if !a.isLoggable() {
                return
        }
        ctx, format, args := a.parseArgs(args...)
        a.logger().Warn(ctx, format, args...)
}

func cronLogger.Error

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/cron.go:

func (c *cronLogger) Error(args ...any) {
        if !c.isLoggable() {
                return
        }
        ctx, format, args := c.parseArgs(args...)
        c.logger().Error(ctx, format, args...)
}

func asyncLogger.Error

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/async.go:

func (a *asyncLogger) Error(args ...any) {
        if !a.isLoggable() {
                return
        }
        ctx, format, args := a.parseArgs(args...)
        a.logger().Error(ctx, format, args...)
}

func metricsLogger.Fatal

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/metrics.go:

func (m *metricsLogger) Fatal(args ...any) {
        if !m.isLoggable() {
                return
        }
        ctx, format, args := m.parseArgs(args...)
        m.logger().Fatal(ctx, format, args...)
}

func cronLogger.Fatal

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/cron.go:

func (c *cronLogger) Fatal(args ...any) {
        if !c.isLoggable() {
                return
        }
        ctx, format, args := c.parseArgs(args...)
        c.logger().Fatal(ctx, format, args...)
}

func asyncLogger.Fatal

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/async.go:

func (a *asyncLogger) Fatal(args ...any) {
        if !a.isLoggable() {
                return
        }
        ctx, format, args := a.parseArgs(args...)
        a.logger().Fatal(ctx, format, args...)
}

func metricsLogger.Error

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/metrics.go:

func (m *metricsLogger) Error(args ...any) {
        if !m.isLoggable() {
                return
        }
        ctx, format, args := m.parseArgs(args...)
        m.logger().Error(ctx, format, args...)
}

func httpLogger.Warnf

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/http.go:

func (h *httpLogger) Warnf(format string, v ...any) {
        if h.reloadConfig(); h.enabled {
                ctx, args := h.parseArgs(v...)
                h.logger().Info(ctx, format, args...)
        }
}

func metricsLogger.Printf

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/metrics.go:

func (m *metricsLogger) Printf(format string, args ...any) {
        if !m.isLoggable() {
                return
        }
        m.logger().Info(context.Background(), format, append(args, metricsFields)...)
}

func DefaultMongoLogger

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/mongo.go:

func DefaultMongoLogger() (logger *mongoLogger) {
        logger = &mongoLogger{
                enabled:    true,
                requestMap: make(map[int64]struct{ commandString string }),
                loggableCommandSet: utils.NewSet[string](
                        "ping",
                        "insert",
                        "find",
                        "update",
                        "delete",
                        "aggregate",
                        "distinct",
                        "count",
                        "findAndModify",
                        "getMore",
                        "killCursors",
                        "create",
                        "drop",
                        "listDatabases",
                        "dropDatabase",
                        "createIndexes",
                        "listIndexes",
                        "dropIndexes",
                        "listCollections",
                ),
        }
        logger.CommandMonitor = &event.CommandMonitor{
                Started:   logger.started,
                Succeeded: logger.succeeded,
                Failed:    logger.failed,
        }
        return
}

func httpLogger.logger

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/http.go:

func (h *httpLogger) logger() log.Loggable {
        if h.log != nil {
                return h.log
        }
        return log.Use(config.DefaultInstanceKey, log.AppName(h.appName))
}

func routineLogger.Printf

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/routine.go:

func (r *routineLogger) Printf(format string, args ...any) {
        if r.reloadConfig(); r.enabled {
                ctx, args := r.parseArgs(args...)
                r.logger().Info(ctx, format, args...)
        }
}

func asyncLogger.Printf

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/async.go:

func (a *asyncLogger) Printf(format string, args ...any) {
        if !a.isLoggable() {
                return
        }
        a.logger().Info(context.Background(), format, append(args, asyncFields)...)
}

func routineLogger.logger

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/routine.go:

func (r *routineLogger) logger() log.Loggable {
        if r.log != nil {
                return r.log
        }
        return log.Use(config.DefaultInstanceKey, log.AppName(r.appName))
}

func gormLogger.Error

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/gorm.go:

func (g *gormLogger) Error(ctx context.Context, msg string, data ...any) {
        if g.isLoggable() && g.logLevel >= logger.Error {
                g.logger().Error(ctx, msg, append(data, dbFields)...)
        }
}

func gormLogger.LogMode

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/gorm.go:

46	`func (g *gormLogger) LogMode(level logger.LogLevel) logger.Interface {`
47	`g.logLevel = level`
48	`return g`
49	`}`

func gormLogger.Warn

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/gorm.go:

func (g *gormLogger) Warn(ctx context.Context, msg string, data ...any) {
        if g.isLoggable() && g.logLevel >= logger.Warn {
                g.logger().Warn(ctx, msg, append(data, dbFields)...)
        }
}

func DefaultHttpLogger

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/http.go:

20	`func DefaultHttpLogger() resty.Logger {`
21	`return new(httpLogger)`
22	`}`

func DefaultRoutineLogger

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/routine.go:

func DefaultRoutineLogger() ants.Logger {
        return &routineLogger{
                enabled: true,
        }
}

func DefaultAsyncLogger

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/async.go:

21	`func DefaultAsyncLogger() interface{ Printf(string, ...any) } {`
22	`return &asyncLogger{}`
23	`}`

func DefaultAsynqAsyncLogger

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/async.go:

25	`func DefaultAsynqAsyncLogger() asynq.Logger {`
26	`return &asyncLogger{}`
27	`}`

func DefaultMySQLLogger

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/gorm.go:

func DefaultMySQLLogger() logger.Interface {
        return &gormLogger{
                enabled:                   true,
                slowThreshold:             200 * time.Millisecond,
                logLevel:                  logger.Silent,
                ignoreRecordNotFoundError: true,
        }
}

func NewLogger

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/mq.go:

32	`func NewLogger() watermill.LoggerAdapter {`
33	`return new(mqLogger)`
34	`}`

func DefaultAsynqCronLogger

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/cron.go:

25	`func DefaultAsynqCronLogger() asynq.Logger {`
26	`return &cronLogger{}`
27	`}`

func DefaultMetricsLogger

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/customlogger/metrics.go:

21	`func DefaultMetricsLogger() metrics.Logger {`
22	`return &metricsLogger{}`
23	`}`

Package Overview: github.com/wfusion/gofusion/log/encoder 100.0%

Please select a function to see what's left for testing.

`@58:9(...)`	`github.com/wfusion/gofusion/log/encoder/skip_caller.go`	`100.0%`	`8/8`
`init(...)`	`github.com/wfusion/gofusion/log/encoder/skip_caller.go`	`100.0%`	`2/2`
`SkipCallerEncoder(...)`	`github.com/wfusion/gofusion/log/encoder/skip_caller.go`	`100.0%`	`2/2`

func @58:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/encoder/skip_caller.go:

func(entryCaller zapcore.EntryCaller, enc zapcore.PrimitiveArrayEncoder) {
                caller := utils.GetCaller(
                        maximumCallerDepth,
                        skipGlobOpt,
                        defaultSuffixedRegOpt,
                        minimumCallerDepthOpt,
                )

                entryCaller.PC = caller.PC
                entryCaller.File = caller.File
                entryCaller.Line = caller.Line
                entryCaller.Function = caller.Function
                if shorter {
                        enc.AppendString(entryCaller.TrimmedPath())
                } else {
                        enc.AppendString(entryCaller.FullPath())
                }
        }

func init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/encoder/skip_caller.go:

49	`func init() {`
50	`defaultSuffixedRegOpt = utils.SkipRegexps(defaultSuffixesRegPatternList...)`
51	`minimumCallerDepthOpt = utils.SkipKnownDepth(knownLogrusFrames)`
52	`}`

func SkipCallerEncoder

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/log/encoder/skip_caller.go:

func SkipCallerEncoder(skipSuffixed []string, shorter bool) func(
        caller zapcore.EntryCaller, enc zapcore.PrimitiveArrayEncoder) {
        skipGlobOpt := utils.SkipGlobs(skipSuffixed...)
        return func(entryCaller zapcore.EntryCaller, enc zapcore.PrimitiveArrayEncoder) {
                caller := utils.GetCaller(
                        maximumCallerDepth,
                        skipGlobOpt,
                        defaultSuffixedRegOpt,
                        minimumCallerDepthOpt,
                )

                entryCaller.PC = caller.PC
                entryCaller.File = caller.File
                entryCaller.Line = caller.Line
                entryCaller.Function = caller.Function
                if shorter {
                        enc.AppendString(entryCaller.TrimmedPath())
                } else {
                        enc.AppendString(entryCaller.FullPath())
                }
        }
}

Package Overview: github.com/wfusion/gofusion/metrics 72.5%

Please select a function to see what's left for testing.

`@32:9(...)`	`github.com/wfusion/gofusion/metrics/construct.go`	`100.0%`	`13/13`
`Internal(...)`	`github.com/wfusion/gofusion/metrics/construct.go`	`100.0%`	`11/11`
`abstract.convertOpts(...)`	`github.com/wfusion/gofusion/metrics/metrics.go`	`100.0%`	`9/9`
`Construct(...)`	`github.com/wfusion/gofusion/metrics/construct.go`	`100.0%`	`7/7`
`@243:5(...)`	`github.com/wfusion/gofusion/metrics/metrics.go`	`100.0%`	`2/2`
`newMock(...)`	`github.com/wfusion/gofusion/metrics/mock.go`	`100.0%`	`2/2`
`@285:57(...)`	`github.com/wfusion/gofusion/metrics/metrics.go`	`100.0%`	`1/1`
`Labels(...)`	`github.com/wfusion/gofusion/metrics/types.go`	`100.0%`	`1/1`
`@126:9(...)`	`github.com/wfusion/gofusion/metrics/types.go`	`100.0%`	`1/1`
`@108:9(...)`	`github.com/wfusion/gofusion/metrics/construct.go`	`100.0%`	`1/1`
`init(...)`	`github.com/wfusion/gofusion/metrics/construct.go`	`100.0%`	`1/1`
`@120:9(...)`	`github.com/wfusion/gofusion/metrics/types.go`	`100.0%`	`1/1`
`WithoutTimeout(...)`	`github.com/wfusion/gofusion/metrics/types.go`	`100.0%`	`1/1`
`AppName(...)`	`github.com/wfusion/gofusion/metrics/construct.go`	`100.0%`	`1/1`
`abstract.SetGauge(...)`	`github.com/wfusion/gofusion/metrics/metrics.go`	`100.0%`	`1/1`
`abstract.IncrCounter(...)`	`github.com/wfusion/gofusion/metrics/metrics.go`	`100.0%`	`1/1`
`abstract.AddSample(...)`	`github.com/wfusion/gofusion/metrics/metrics.go`	`100.0%`	`1/1`
`abstract.MeasureSince(...)`	`github.com/wfusion/gofusion/metrics/metrics.go`	`100.0%`	`1/1`
`abstract.IsEnableServiceLabel(...)`	`github.com/wfusion/gofusion/metrics/metrics.go`	`100.0%`	`1/1`
`@336:33(...)`	`github.com/wfusion/gofusion/metrics/metrics.go`	`100.0%`	`1/1`
`abstract.convertLabels(...)`	`github.com/wfusion/gofusion/metrics/metrics.go`	`100.0%`	`1/1`
`@114:9(...)`	`github.com/wfusion/gofusion/metrics/types.go`	`100.0%`	`1/1`
`abstract.start(...)`	`github.com/wfusion/gofusion/metrics/metrics.go`	`100.0%`	`1/1`
`PrometheusBuckets(...)`	`github.com/wfusion/gofusion/metrics/types.go`	`100.0%`	`1/1`
`Timeout(...)`	`github.com/wfusion/gofusion/metrics/types.go`	`100.0%`	`1/1`
`@108:9(...)`	`github.com/wfusion/gofusion/metrics/types.go`	`100.0%`	`1/1`
`@262:36(...)`	`github.com/wfusion/gofusion/metrics/metrics.go`	`100.0%`	`1/1`
`Precision(...)`	`github.com/wfusion/gofusion/metrics/types.go`	`100.0%`	`1/1`
`@102:9(...)`	`github.com/wfusion/gofusion/metrics/types.go`	`100.0%`	`1/1`
`newMetrics(...)`	`github.com/wfusion/gofusion/metrics/metrics.go`	`96.0%`	`24/25`
`addConfig(...)`	`github.com/wfusion/gofusion/metrics/construct.go`	`90.9%`	`20/22`
`use(...)`	`github.com/wfusion/gofusion/metrics/construct.go`	`87.0%`	`20/23`
`abstract.setGaugeWithLabels(...)`	`github.com/wfusion/gofusion/metrics/metrics.go`	`85.7%`	`6/7`
`abstract.addSampleWithLabels(...)`	`github.com/wfusion/gofusion/metrics/metrics.go`	`85.7%`	`6/7`
`@279:23(...)`	`github.com/wfusion/gofusion/metrics/metrics.go`	`85.7%`	`6/7`
`Use(...)`	`github.com/wfusion/gofusion/metrics/construct.go`	`80.0%`	`8/10`
`abstract.shutdown(...)`	`github.com/wfusion/gofusion/metrics/metrics.go`	`75.0%`	`3/4`
`abstract.measureSinceWithLabels(...)`	`github.com/wfusion/gofusion/metrics/metrics.go`	`75.0%`	`3/4`
`@245:19(...)`	`github.com/wfusion/gofusion/metrics/metrics.go`	`75.0%`	`3/4`
`newPrometheusPush(...)`	`github.com/wfusion/gofusion/metrics/prometheus.go`	`75.0%`	`3/4`
`abstract.process(...)`	`github.com/wfusion/gofusion/metrics/metrics.go`	`75.0%`	`3/4`
`abstract.incrCounterWithLabels(...)`	`github.com/wfusion/gofusion/metrics/metrics.go`	`75.0%`	`3/4`
`@246:25(...)`	`github.com/wfusion/gofusion/metrics/metrics.go`	`70.0%`	`7/10`
`abstract.send(...)`	`github.com/wfusion/gofusion/metrics/metrics.go`	`24.2%`	`8/33`
`HttpHandler(...)`	`github.com/wfusion/gofusion/metrics/http.go`	`0.0%`	`0/12`
`newPrometheusPull(...)`	`github.com/wfusion/gofusion/metrics/prometheus.go`	`0.0%`	`0/8`
`task.String(...)`	`github.com/wfusion/gofusion/metrics/metrics.go`	`0.0%`	`0/4`
`abstract.getProxy(...)`	`github.com/wfusion/gofusion/metrics/metrics.go`	`0.0%`	`0/1`
`@114:9(...)`	`github.com/wfusion/gofusion/metrics/construct.go`	`0.0%`	`0/1`
`NewDI(...)`	`github.com/wfusion/gofusion/metrics/construct.go`	`0.0%`	`0/1`

func @32:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/construct.go:

func() {
                rwlock.Lock()
                defer rwlock.Unlock()

                pid := syscall.Getpid()
                app := config.Use(opt.AppName).AppName()
                if appInstances != nil {
                        for _, sinks := range appInstances[opt.AppName] {
                                for name, sink := range sinks {
                                        log.Printf("%v [Gofusion] %s %s %s router exiting...",
                                                pid, app, config.ComponentMetrics, name)
                                        sink.shutdown()
                                        log.Printf("%v [Gofusion] %s %s %s router exited",
                                                pid, app, config.ComponentMetrics, name)
                                }
                        }
                        delete(appInstances, opt.AppName)
                }

                if cfgsMap != nil {
                        delete(cfgsMap, opt.AppName)
                }
        }

func Internal

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/construct.go:

func Internal(opts ...utils.OptionExtender) (sinks []Sink) {
        opt := utils.ApplyOptions[useOption](opts...)
        appName := config.Use(opt.appName).AppName()
        rwlock.Lock()
        defer rwlock.Unlock()
        cfgs, ok := cfgsMap[opt.appName]
        if !ok {
                return
        }
        for _, cfg := range cfgs {
                if cfg.c.EnableInternalMetrics {
                        sinks = append(sinks, use(appName, cfg))
                }
        }
        return
}

func abstract.convertOpts

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/metrics.go:

func (a *abstract) convertOpts(src ...utils.OptionExtender) (dst []utils.OptionExtender) {
        if src == nil {
                return
        }

        dst = make([]utils.OptionExtender, 0, len(src))
        opt := utils.ApplyOptions[option](src...)
        if opt.precision {
                dst = append(dst, metrics.Precision())
        }
        if len(opt.prometheusBuckets) > 0 {
                dst = append(dst, prometheus.Bucket(opt.prometheusBuckets))
        }

        return
}

func Construct

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/construct.go:

func Construct(ctx context.Context, confs map[string]*Conf, opts ...utils.OptionExtender) func() {
        opt := utils.ApplyOptions[config.InitOption](opts...)
        optU := utils.ApplyOptions[useOption](opts...)
        if opt.AppName == "" {
                opt.AppName = optU.appName
        }
        for name, conf := range confs {
                addConfig(ctx, name, conf, opt)
        }

        return func() {
                rwlock.Lock()
                defer rwlock.Unlock()

                pid := syscall.Getpid()
                app := config.Use(opt.AppName).AppName()
                if appInstances != nil {
                        for _, sinks := range appInstances[opt.AppName] {
                                for name, sink := range sinks {
                                        log.Printf("%v [Gofusion] %s %s %s router exiting...",
                                                pid, app, config.ComponentMetrics, name)
                                        sink.shutdown()
                                        log.Printf("%v [Gofusion] %s %s %s router exited",
                                                pid, app, config.ComponentMetrics, name)
                                }
                        }
                        delete(appInstances, opt.AppName)
                }

                if cfgsMap != nil {
                        delete(cfgsMap, opt.AppName)
                }
        }
}

func @243:5

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/metrics.go:

func() {
                appName := config.Use(a.appName).AppName()
                _ = retry.Retry(func(attempt uint) (err error) {
                        _, err = utils.Catch(func() {
                                for {
                                        select {
                                        case <-a.ctx.Done():
                                                if a.log != nil {
                                                        a.log.Info(a.ctx, "%v [Gofusion] %s %s %s process exited due to context done",
                                                                syscall.Getpid(), config.Use(a.appName).AppName(), config.ComponentMetrics, a.name)
                                                        return
                                                }
                                        case task, ok := <-a.queue:
                                                if !ok {
                                                        a.log.Info(a.ctx, "%v [Gofusion] %s %s %s process exited due to queue closed",
                                                                syscall.Getpid(), config.Use(a.appName).AppName(), config.ComponentMetrics, a.name)
                                                        return
                                                }

                                                if err := a.queuePool.Submit(func() { _ = a.process(task) }); err != nil && a.log != nil {
                                                        a.log.Error(task.ctx, "%v [Gofusion] %s %s %s submit process %s error: %s",
                                                                syscall.Getpid(), config.Use(a.appName).AppName(), config.ComponentMetrics,
                                                                a.name, task, err)
                                                }
                                        }
                                }
                        })
                        if err != nil {
                                a.log.Warn(a.ctx, "%v [Gofusion] %s %s %s dispatcher exited with error: %s",
                                        syscall.Getpid(), appName, config.ComponentMetrics, a.name, err)
                        }
                        return
                }, strategy.Limit(10000))
        }

func newMock

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/mock.go:

13	`func newMock(ctx context.Context, appName, name, job string, conf *cfg) Sink {`
14	`sink := new(metrics.BlackholeSink)`
15	`return &mock{abstract: newMetrics(ctx, appName, name, job, sink, conf)}`
16	`}`

func @285:57

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/metrics.go:

285	`func(o utils.OptionExtender) any { return o }`

func Labels

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/types.go:

func Labels(labels []Label) utils.OptionFunc[option] {
        return func(o *option) {
                o.labels = labels
        }
}

func @126:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/types.go:

126	`func(o *option) {`
127	`o.labels = labels`
128	`}`

func @108:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/construct.go:

108	`func(o *useOption) {`
109	`o.appName = name`
110	`}`

func init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/construct.go:

194	`func init() {`
195	`config.AddComponent(config.ComponentMetrics, Construct)`
196	`}`

func @120:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/types.go:

120	`func(o *option) {`
121	`o.timeout = -1`
122	`}`

func WithoutTimeout

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/types.go:

func WithoutTimeout() utils.OptionFunc[option] {
        return func(o *option) {
                o.timeout = -1
        }
}

func AppName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/construct.go:

func AppName(name string) utils.OptionFunc[useOption] {
        return func(o *useOption) {
                o.appName = name
        }
}

func abstract.SetGauge

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/metrics.go:

128	`func (a *abstract) SetGauge(ctx context.Context, key []string, val float64, opts ...utils.OptionExtender) {`
129	`a.send(ctx, "Gauge", key, val, opts...)`
130	`}`

func abstract.IncrCounter

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/metrics.go:

131	`func (a *abstract) IncrCounter(ctx context.Context, key []string, val float64, opts ...utils.OptionExtender) {`
132	`a.send(ctx, "Counter", key, val, opts...)`
133	`}`

func abstract.AddSample

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/metrics.go:

134	`func (a *abstract) AddSample(ctx context.Context, key []string, val float64, opts ...utils.OptionExtender) {`
135	`a.send(ctx, "Sample", key, val, opts...)`
136	`}`

func abstract.MeasureSince

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/metrics.go:

137	`func (a *abstract) MeasureSince(ctx context.Context, key []string, start time.Time, opts ...utils.OptionExtender) {`
138	`a.send(ctx, "MeasureSince", key, start, opts...)`
139	`}`

func abstract.IsEnableServiceLabel

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/metrics.go:

140	`func (a *abstract) IsEnableServiceLabel() bool { return a.EnableServiceLabel }`

func @336:33

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/metrics.go:

func(l Label) metrics.Label {
                return metrics.Label{
                        Name:  l.Key,
                        Value: l.Value,
                }
        }

func abstract.convertLabels

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/metrics.go:

func (a *abstract) convertLabels(src []Label) (dst []metrics.Label) {
        return utils.SliceMapping(src, func(l Label) metrics.Label {
                return metrics.Label{
                        Name:  l.Key,
                        Value: l.Value,
                }
        })
}

func @114:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/types.go:

114	`func(o *option) {`
115	`o.timeout = timeout`
116	`}`

func abstract.start

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/metrics.go:

func (a *abstract) start() {
        go func() {
                appName := config.Use(a.appName).AppName()
                _ = retry.Retry(func(attempt uint) (err error) {
                        _, err = utils.Catch(func() {
                                for {
                                        select {
                                        case <-a.ctx.Done():
                                                if a.log != nil {
                                                        a.log.Info(a.ctx, "%v [Gofusion] %s %s %s process exited due to context done",
                                                                syscall.Getpid(), config.Use(a.appName).AppName(), config.ComponentMetrics, a.name)
                                                        return
                                                }
                                        case task, ok := <-a.queue:
                                                if !ok {
                                                        a.log.Info(a.ctx, "%v [Gofusion] %s %s %s process exited due to queue closed",
                                                                syscall.Getpid(), config.Use(a.appName).AppName(), config.ComponentMetrics, a.name)
                                                        return
                                                }

                                                if err := a.queuePool.Submit(func() { _ = a.process(task) }); err != nil && a.log != nil {
                                                        a.log.Error(task.ctx, "%v [Gofusion] %s %s %s submit process %s error: %s",
                                                                syscall.Getpid(), config.Use(a.appName).AppName(), config.ComponentMetrics,
                                                                a.name, task, err)
                                                }
                                        }
                                }
                        })
                        if err != nil {
                                a.log.Warn(a.ctx, "%v [Gofusion] %s %s %s dispatcher exited with error: %s",
                                        syscall.Getpid(), appName, config.ComponentMetrics, a.name, err)
                        }
                        return
                }, strategy.Limit(10000))
        }()
}

func PrometheusBuckets

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/types.go:

func PrometheusBuckets(buckets []float64) utils.OptionFunc[option] {
        return func(o *option) {
                o.prometheusBuckets = buckets
        }
}

func Timeout

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/types.go:

func Timeout(timeout time.Duration) utils.OptionFunc[option] {
        return func(o *option) {
                o.timeout = timeout
        }
}

func @108:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/types.go:

108	`func(o *option) {`
109	`o.precision = true`
110	`}`

func @262:36

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/metrics.go:

262	`func() { _ = a.process(task) }`

func Precision

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/types.go:

func Precision() utils.OptionFunc[option] {
        return func(o *option) {
                o.precision = true
        }
}

func @102:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/types.go:

102	`func(o *option) {`
103	`o.prometheusBuckets = buckets`
104	`}`

func newMetrics

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/metrics.go:

func newMetrics(ctx context.Context, appName, name, job string, sink metrics.MetricSink, conf *cfg) *abstract {
        metricsConfig := metrics.DefaultConfig(config.Use(appName).AppName())
        if conf.c.EnableServiceLabel {
                metricsConfig.EnableHostname = true
                metricsConfig.EnableHostnameLabel = true
                metricsConfig.EnableServiceLabel = true
                metricsConfig.EnableClientIPLabel = true
        } else {
                metricsConfig.EnableHostname = false
                metricsConfig.EnableHostnameLabel = false
                metricsConfig.EnableServiceLabel = false
                metricsConfig.EnableClientIPLabel = false
        }

        m, err := metrics.New(metricsConfig, sink)
        if err != nil {
                panic(errors.Errorf("initialize metrics failed: %s", err))
        }

        limit := defaultQueueLimit
        if conf.c.QueueLimit > 0 {
                limit = conf.c.QueueLimit
        }
        if conf.c.QueueConcurrency == 0 {
                conf.c.QueueConcurrency = runtime.NumCPU()
        }

        constLabels := make([]metrics.Label, 0, len(conf.c.Labels))
        for k, v := range conf.c.Labels {
                constLabels = append(constLabels, metrics.Label{Name: k, Value: v})
        }

        a := &abstract{
                Metrics: m,

                ctx:         ctx,
                constLabels: constLabels,
                job:         job,
                name:        name,
                appName:     appName,
                log:         conf.logger,
                stop:        make(chan struct{}),
                queue:       make(chan *task, limit),
                queuePool:   utils.Must(ants.NewPool(conf.c.QueueConcurrency)),
        }

        a.dispatcher = map[string]func(...any){
                "Gauge":        utils.WrapFunc(a.setGaugeWithLabels),
                "Counter":      utils.WrapFunc(a.incrCounterWithLabels),
                "Sample":       utils.WrapFunc(a.addSampleWithLabels),
                "MeasureSince": utils.WrapFunc(a.measureSinceWithLabels),
        }

        a.start()

        return a
}

func addConfig

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/construct.go:

func addConfig(ctx context.Context, name string, conf *Conf, opt *config.InitOption) {
        var (
                err      error
                interval time.Duration
        )
        if utils.IsStrNotBlank(conf.Interval) {
                interval, err = time.ParseDuration(conf.Interval)
                if err != nil {
                        panic(errors.Errorf("metrics component parse %s interval failed: %s", name, err))
                }
        }

        rwlock.Lock()
        defer rwlock.Unlock()
        if cfgsMap == nil {
                cfgsMap = make(map[string]map[string]*cfg)
        }
        if cfgsMap[opt.AppName] == nil {
                cfgsMap[opt.AppName] = make(map[string]*cfg)
        }
        if _, ok := cfgsMap[opt.AppName][name]; ok {
                panic(ErrDuplicatedName)
        }

        var logger metrics.Logger
        if utils.IsStrNotBlank(conf.Logger) {
                loggerType := inspect.TypeOf(conf.Logger)
                loggerValue := reflect.New(loggerType)
                if loggerValue.Type().Implements(customLoggerType) {
                        logger := fusLog.Use(conf.LogInstance, fusLog.AppName(opt.AppName))
                        loggerValue.Interface().(customLogger).Init(logger, opt.AppName, name)
                }
                logger = loggerValue.Convert(metricsLoggerType).Interface().(metrics.Logger)
        }

        cfgsMap[opt.AppName][name] = &cfg{
                c:          conf,
                ctx:        ctx,
                name:       name,
                appName:    opt.AppName,
                interval:   interval,
                initOption: opt,
                logger:     logger,
        }
}

func use

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/construct.go:

func use(job string, conf *cfg) (sink Sink) {
        if appInstances == nil {
                appInstances = make(map[string]map[string]map[string]Sink)
        }
        instances, ok := appInstances[conf.appName]
        if !ok {
                instances = make(map[string]map[string]Sink)
                appInstances[conf.appName] = instances
        }

        jobs, ok := instances[conf.name]
        if !ok {
                jobs = make(map[string]Sink)
                instances[conf.name] = jobs
        }
        sink, ok = jobs[job]
        if ok {
                return
        }

        switch conf.c.Type {
        case metricsTypePrometheus:
                switch conf.c.Mode {
                case modePull:
                        sink = newPrometheusPull(conf.ctx, conf.appName, conf.name, job, conf)
                case modePush:
                        sink = newPrometheusPush(conf.ctx, conf.appName, conf.name, job, conf.interval, conf)
                }
        case metricsTypeMock:
                sink = newMock(conf.ctx, conf.appName, conf.name, job, conf)
        default:
                panic(errors.Errorf("unknown metrics type: %s", conf.c.Type))
        }

        if sink == nil {
                panic(errors.Errorf("unknown metrics mode: %s", conf.c.Mode))
        }

        jobs[job] = sink
        return
}

func abstract.setGaugeWithLabels

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/metrics.go:

func (a *abstract) setGaugeWithLabels(key []string, v any, labels []metrics.Label, opts ...utils.OptionExtender) {
        val, ok := v.(float64)
        if !ok {
                return
        }
        opt := utils.ApplyOptions[option](opts...)
        if opt.precision {
                a.Metrics.SetPrecisionGaugeWithLabels(key, val, labels, opts...)
        } else {
                a.Metrics.SetGaugeWithLabels(key, float32(val), labels, opts...)
        }
}

func abstract.addSampleWithLabels

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/metrics.go:

func (a *abstract) addSampleWithLabels(key []string, v any, labels []metrics.Label, opts ...utils.OptionExtender) {
        val, ok := v.(float64)
        if !ok {
                return
        }
        opt := utils.ApplyOptions[option](opts...)
        if opt.precision {
                a.Metrics.AddPrecisionSampleWithLabels(key, val, labels, opts...)
        } else {
                a.Metrics.AddSampleWithLabels(key, float32(val), labels, opts...)
        }
}

func @279:23

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/metrics.go:

func() (err error) {
                handler, ok := a.dispatcher[task.method]
                if !ok {
                        return errors.Errorf("method %s not found", task.method)
                }
                params := []any{task.key, task.val, append(task.labels, a.constLabels...)}
                params = append(params, utils.SliceMapping(task.opts, func(o utils.OptionExtender) any { return o })...)
                handler(params...)
                return
        }

func Use

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/construct.go:

func Use(name, job string, opts ...utils.OptionExtender) Sink {
        opt := utils.ApplyOptions[useOption](opts...)
        rwlock.Lock()
        defer rwlock.Unlock()
        cfgs, ok := cfgsMap[opt.appName]
        if !ok {
                panic(errors.Errorf("app metrics config not found: %s", opt.appName))
        }
        cfg, ok := cfgs[name]
        if !ok {
                panic(errors.Errorf("metrics config not found: %s", name))
        }

        return use(job, cfg)
}

func abstract.shutdown

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/metrics.go:

func (a *abstract) shutdown() {
        if _, ok := utils.IsChannelClosed(a.stop); ok {
                return
        }

        close(a.stop)
        a.Metrics.Shutdown()
}

func abstract.measureSinceWithLabels

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/metrics.go:

func (a *abstract) measureSinceWithLabels(key []string, v any, labels []metrics.Label, opts ...utils.OptionExtender) {
        start, ok := v.(time.Time)
        if !ok {
                return
        }
        a.Metrics.MeasureSinceWithLabels(key, start, labels, opts...)
}

func @245:19

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/metrics.go:

func(attempt uint) (err error) {
                        _, err = utils.Catch(func() {
                                for {
                                        select {
                                        case <-a.ctx.Done():
                                                if a.log != nil {
                                                        a.log.Info(a.ctx, "%v [Gofusion] %s %s %s process exited due to context done",
                                                                syscall.Getpid(), config.Use(a.appName).AppName(), config.ComponentMetrics, a.name)
                                                        return
                                                }
                                        case task, ok := <-a.queue:
                                                if !ok {
                                                        a.log.Info(a.ctx, "%v [Gofusion] %s %s %s process exited due to queue closed",
                                                                syscall.Getpid(), config.Use(a.appName).AppName(), config.ComponentMetrics, a.name)
                                                        return
                                                }

                                                if err := a.queuePool.Submit(func() { _ = a.process(task) }); err != nil && a.log != nil {
                                                        a.log.Error(task.ctx, "%v [Gofusion] %s %s %s submit process %s error: %s",
                                                                syscall.Getpid(), config.Use(a.appName).AppName(), config.ComponentMetrics,
                                                                a.name, task, err)
                                                }
                                        }
                                }
                        })
                        if err != nil {
                                a.log.Warn(a.ctx, "%v [Gofusion] %s %s %s dispatcher exited with error: %s",
                                        syscall.Getpid(), appName, config.ComponentMetrics, a.name, err)
                        }
                        return
                }

func newPrometheusPush

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/prometheus.go:

func newPrometheusPush(ctx context.Context, appName, name, job string, interval time.Duration, conf *cfg) Sink {
        sink, err := prometheus.NewPrometheusPushSink(ctx, conf.c.Endpoint.Addresses[0], interval, job, conf.logger)
        if err != nil {
                panic(errors.Errorf("initialize metrics component push mode prometheus failed: %s", err))
        }
        return &_Prometheus{abstract: newMetrics(ctx, appName, name, job, sink, conf)}
}

func abstract.process

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/metrics.go:

func (a *abstract) process(task *task) (err error) {
        _, err = utils.Catch(func() (err error) {
                handler, ok := a.dispatcher[task.method]
                if !ok {
                        return errors.Errorf("method %s not found", task.method)
                }
                params := []any{task.key, task.val, append(task.labels, a.constLabels...)}
                params = append(params, utils.SliceMapping(task.opts, func(o utils.OptionExtender) any { return o })...)
                handler(params...)
                return
        })
        if err != nil && a.log != nil {
                a.log.Error(task.ctx, "%v [Gofusion] %s %s %s process %s catch error: %s",
                        syscall.Getpid(), config.Use(a.appName).AppName(), config.ComponentMetrics, a.name, task, err)
        }
        return
}

func abstract.incrCounterWithLabels

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/metrics.go:

func (a *abstract) incrCounterWithLabels(key []string, v any, labels []metrics.Label, opts ...utils.OptionExtender) {
        val, ok := v.(float64)
        if !ok {
                return
        }
        a.Metrics.IncrCounterWithLabels(key, float32(val), labels, opts...)
}

func @246:25

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/metrics.go:

func() {
                                for {
                                        select {
                                        case <-a.ctx.Done():
                                                if a.log != nil {
                                                        a.log.Info(a.ctx, "%v [Gofusion] %s %s %s process exited due to context done",
                                                                syscall.Getpid(), config.Use(a.appName).AppName(), config.ComponentMetrics, a.name)
                                                        return
                                                }
                                        case task, ok := <-a.queue:
                                                if !ok {
                                                        a.log.Info(a.ctx, "%v [Gofusion] %s %s %s process exited due to queue closed",
                                                                syscall.Getpid(), config.Use(a.appName).AppName(), config.ComponentMetrics, a.name)
                                                        return
                                                }

                                                if err := a.queuePool.Submit(func() { _ = a.process(task) }); err != nil && a.log != nil {
                                                        a.log.Error(task.ctx, "%v [Gofusion] %s %s %s submit process %s error: %s",
                                                                syscall.Getpid(), config.Use(a.appName).AppName(), config.ComponentMetrics,
                                                                a.name, task, err)
                                                }
                                        }
                                }
                        }

func abstract.send

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/metrics.go:

func (a *abstract) send(ctx context.Context, method string, key []string, val any, opts ...utils.OptionExtender) {
        opt := utils.ApplyOptions[option](opts...)

        t := &task{
                ctx:    ctx,
                key:    key,
                val:    val,
                opts:   append(opts, a.convertOpts(opts...)...),
                labels: a.convertLabels(opt.labels),
                method: method,
        }

        switch {
        case opt.timeout > 0:
                timeoutCtx, cancel := context.WithTimeout(a.ctx, opt.timeout)
                defer cancel()

                select {
                case a.queue <- t:
                case <-ctx.Done():
                        if a.log != nil {
                                a.log.Info(ctx, "%v [Gofusion] %s %s %s async send task canceled due to context done",
                                        syscall.Getpid(), config.Use(a.appName).AppName(), config.ComponentMetrics, a.name)
                        }
                case <-timeoutCtx.Done():
                        if a.log != nil {
                                a.log.Warn(ctx, "%v [Gofusion] %s %s %s async send task canceled due to timeout %s",
                                        syscall.Getpid(), config.Use(a.appName).AppName(), config.ComponentMetrics, a.name, opt.timeout)
                        }
                case <-a.stop:
                        close(a.queue)
                        if a.log != nil {
                                a.log.Info(ctx, "%v [Gofusion] %s %s %s async send task canceled due to metrics stopped",
                                        syscall.Getpid(), config.Use(a.appName).AppName(), config.ComponentMetrics, a.name)
                        }
                case <-a.ctx.Done():
                        if a.log != nil {
                                a.log.Info(ctx, "%v [Gofusion] %s %s %s async send task canceled due to app exited",
                                        syscall.Getpid(), config.Use(a.appName).AppName(), config.ComponentMetrics, a.name)
                        }
                }
        case opt.timeout < 0:
                select {
                case a.queue <- t:
                case <-ctx.Done():
                        if a.log != nil {
                                a.log.Info(ctx, "%v [Gofusion] %s %s %s async send task canceled due to context done",
                                        syscall.Getpid(), config.Use(a.appName).AppName(), config.ComponentMetrics, a.name)
                        }
                case <-a.stop:
                        close(a.queue)
                        if a.log != nil {
                                a.log.Info(ctx, "%v [Gofusion] %s %s %s async send task canceled due to metrics stopped",
                                        syscall.Getpid(), config.Use(a.appName).AppName(), config.ComponentMetrics, a.name)
                        }
                case <-a.ctx.Done():
                        if a.log != nil {
                                a.log.Info(ctx, "%v [Gofusion] %s %s %s async send task canceled due to app exited",
                                        syscall.Getpid(), config.Use(a.appName).AppName(), config.ComponentMetrics, a.name)
                        }
                }
        default:
                select {
                case a.queue <- t:
                case <-ctx.Done():
                        if a.log != nil {
                                a.log.Info(ctx, "%v [Gofusion] %s %s %s async send task canceled due to context done",
                                        syscall.Getpid(), config.Use(a.appName).AppName(), config.ComponentMetrics, a.name)
                        }
                case <-a.ctx.Done():
                        if a.log != nil {
                                a.log.Info(ctx, "%v [Gofusion] %s %s %s async send task canceled due to app exited",
                                        syscall.Getpid(), config.Use(a.appName).AppName(), config.ComponentMetrics, a.name)
                        }
                case <-a.stop:
                        close(a.queue)
                        if a.log != nil {
                                a.log.Info(ctx, "%v [Gofusion] %s %s %s async send task canceled due to metrics stopped",
                                        syscall.Getpid(), config.Use(a.appName).AppName(), config.ComponentMetrics, a.name)
                        }
                default:
                        if a.log != nil {
                                a.log.Warn(ctx, "%v [Gofusion] %s %s %s async send task canceled due to exceed the queue limit",
                                        syscall.Getpid(), config.Use(a.appName).AppName(), config.ComponentMetrics, a.name)
                        }
                }
        }
}

func HttpHandler

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/http.go:

func HttpHandler(path, name string, opts ...utils.OptionExtender) http.Handler {
        opt := utils.ApplyOptions[useOption](opts...)
        rwlock.RLock()
        defer rwlock.RUnlock()

        if appInstances == nil || appInstances[opt.appName] == nil || appInstances[opt.appName][name] == nil {
                panic(errors.Errorf("metrics instance not found: %s %s", opt.appName, name))
        }

        // cfg := cfgsMap[opt.appName][name]
        m := utils.MapValues(appInstances[opt.appName][name])[0]
        switch sink := m.getProxy().(type) {
        case *prometheus.PrometheusSink:
                gatherer, ok := sink.Registry.(proDrv.Gatherer)
                if !ok {
                        gatherer = proDrv.DefaultGatherer
                }
                return promhttp.InstrumentMetricHandler(
                        sink.Registry, promhttp.HandlerFor(gatherer, promhttp.HandlerOpts{}),
                )
        default:
                panic(errors.Errorf("metrics instance not support http exporter: %s %s", opt.appName, name))
        }
}

func newPrometheusPull

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/prometheus.go:

func newPrometheusPull(ctx context.Context, appName, name, job string, conf *cfg) Sink {
        prometheusRWLocker.Lock()
        if _, ok := prometheusRegisters[appName]; !ok {
                prometheusRegisters[appName] = proDrv.NewRegistry()
        }
        prometheusRWLocker.Unlock()

        sink, err := prometheus.NewPrometheusSinkFrom(prometheus.PrometheusOpts{
                Expiration:           prometheus.DefaultPrometheusOpts.Expiration,
                Registerer:           prometheusRegisters[appName],
                GaugeDefinitions:     nil,
                SummaryDefinitions:   nil,
                CounterDefinitions:   nil,
                HistogramDefinitions: nil,
                Name:                 job,
        })
        if err != nil {
                panic(errors.Errorf("initialize metrics component pull mode prometheus failed: %s", err))
        }

        return &_Prometheus{abstract: newMetrics(ctx, appName, name, job, sink, conf)}
}

func task.String

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/metrics.go:

func (t *task) String() string {
        label := make(map[string]string, len(t.labels))
        for _, l := range t.labels {
                label[l.Name] = l.Value
        }

        return fmt.Sprintf("%s:%s:%+v(%+v)", t.method, strings.Join(t.key, constant.Dot), t.val, label)
}

func abstract.getProxy

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/metrics.go:

142	`func (a *abstract) getProxy() any {`
143	`return inspect.GetField[metrics.MetricSink](a.Metrics, "sink")`
144	`}`

func @114:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/construct.go:

114	`func() Sink {`
115	`return Use(name, job, opts...)`
116	`}`

func NewDI

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/metrics/construct.go:

func NewDI(name, job string, opts ...utils.OptionExtender) func() Sink {
        return func() Sink {
                return Use(name, job, opts...)
        }
}

Package Overview: github.com/wfusion/gofusion/mongo 76.6%

Please select a function to see what's left for testing.

`metricsPoolMonitor(...)`	`github.com/wfusion/gofusion/mongo/metrics.go`	`100.0%`	`13/13`
`startDaemonRoutines(...)`	`github.com/wfusion/gofusion/mongo/metrics.go`	`100.0%`	`10/10`
`Construct(...)`	`github.com/wfusion/gofusion/mongo/construct.go`	`100.0%`	`7/7`
`@160:9(...)`	`github.com/wfusion/gofusion/mongo/metrics.go`	`100.0%`	`5/5`
`@59:25(...)`	`github.com/wfusion/gofusion/mongo/metrics.go`	`100.0%`	`4/4`
`@83:9(...)`	`github.com/wfusion/gofusion/mongo/mongo.go`	`100.0%`	`1/1`
`init(...)`	`github.com/wfusion/gofusion/mongo/construct.go`	`100.0%`	`1/1`
`metricMongoStats(...)`	`github.com/wfusion/gofusion/mongo/metrics.go`	`100.0%`	`1/1`
`AppName(...)`	`github.com/wfusion/gofusion/mongo/mongo.go`	`100.0%`	`1/1`
`WriteConcern(...)`	`github.com/wfusion/gofusion/mongo/mongo.go`	`100.0%`	`1/1`
`@72:9(...)`	`github.com/wfusion/gofusion/mongo/mongo.go`	`100.0%`	`1/1`
`instance.GetProxy(...)`	`github.com/wfusion/gofusion/mongo/mongo.go`	`100.0%`	`1/1`
`instance.Database(...)`	`github.com/wfusion/gofusion/mongo/mongo.go`	`100.0%`	`1/1`
`addInstance(...)`	`github.com/wfusion/gofusion/mongo/construct.go`	`91.3%`	`21/23`
`@33:9(...)`	`github.com/wfusion/gofusion/mongo/construct.go`	`88.9%`	`8/9`
`Use(...)`	`github.com/wfusion/gofusion/mongo/mongo.go`	`81.8%`	`9/11`
`metricMongoLatency(...)`	`github.com/wfusion/gofusion/mongo/metrics.go`	`66.7%`	`2/3`
`@101:21(...)`	`github.com/wfusion/gofusion/mongo/metrics.go`	`60.0%`	`12/20`
`@57:21(...)`	`github.com/wfusion/gofusion/mongo/metrics.go`	`47.4%`	`9/19`
`@87:4(...)`	`github.com/wfusion/gofusion/mongo/construct.go`	`0.0%`	`0/1`
`ReadConcern(...)`	`github.com/wfusion/gofusion/mongo/mongo.go`	`0.0%`	`0/1`
`@78:9(...)`	`github.com/wfusion/gofusion/mongo/mongo.go`	`0.0%`	`0/1`
`@88:9(...)`	`github.com/wfusion/gofusion/mongo/mongo.go`	`0.0%`	`0/1`
`BsonOptions(...)`	`github.com/wfusion/gofusion/mongo/mongo.go`	`0.0%`	`0/1`
`@93:9(...)`	`github.com/wfusion/gofusion/mongo/mongo.go`	`0.0%`	`0/1`
`Registry(...)`	`github.com/wfusion/gofusion/mongo/mongo.go`	`0.0%`	`0/1`
`@98:9(...)`	`github.com/wfusion/gofusion/mongo/mongo.go`	`0.0%`	`0/1`
`ReadPreference(...)`	`github.com/wfusion/gofusion/mongo/mongo.go`	`0.0%`	`0/1`

func metricsPoolMonitor

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mongo/metrics.go:

func metricsPoolMonitor(appName, name string) func(evt *event.PoolEvent) {
        metricsPoolLocker.Lock()
        defer metricsPoolLocker.Unlock()
        if metricsPoolTotalCounter[appName] == nil {
                metricsPoolTotalCounter[appName] = make(map[string]*atomic.Int64)
        }
        if metricsPoolTotalCounter[appName][name] == nil {
                metricsPoolTotalCounter[appName][name] = atomic.NewInt64(0)
        }
        if metricsPoolInUseCounter[appName] == nil {
                metricsPoolInUseCounter[appName] = make(map[string]*atomic.Int64)
        }
        if metricsPoolInUseCounter[appName][name] == nil {
                metricsPoolInUseCounter[appName][name] = atomic.NewInt64(0)
        }

        inuse := metricsPoolInUseCounter[appName][name]
        total := metricsPoolTotalCounter[appName][name]
        return func(evt *event.PoolEvent) {
                switch evt.Type {
                case event.PoolCreated:
                case event.PoolReady:
                case event.PoolCleared:
                case event.PoolClosedEvent:
                case event.ConnectionCreated:
                        total.Add(1)
                case event.ConnectionReady:
                case event.ConnectionClosed:
                        total.Add(-1)
                case event.GetStarted:
                case event.GetFailed:
                case event.GetSucceeded:
                        inuse.Add(1)
                case event.ConnectionReturned:
                        inuse.Add(-1)
                }
        }

}

func startDaemonRoutines

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mongo/metrics.go:

func startDaemonRoutines(ctx context.Context, appName, name string, conf *Conf) {
        ticker := time.Tick(time.Second * 5)
        app := config.Use(appName).AppName()
        labels := []metrics.Label{
                {Key: "config", Value: name},
                {Key: "database", Value: conf.DB},
        }

        log.Printf("%v [Gofusion] %s %s %s metrics start", syscall.Getpid(), app, config.ComponentMongo, name)
        for {
                select {
                case <-ctx.Done():
                        log.Printf("%v [Gofusion] %s %s %s metrics exited",
                                syscall.Getpid(), app, config.ComponentMongo, name)
                        return
                case <-ticker:
                        go metricMongoStats(ctx, appName, name, labels)
                        go metricMongoLatency(ctx, appName, name, labels)
                }
        }
}

func Construct

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mongo/construct.go:

func Construct(ctx context.Context, confs map[string]*Conf, opts ...utils.OptionExtender) func() {
        opt := utils.ApplyOptions[config.InitOption](opts...)
        optU := utils.ApplyOptions[useOption](opts...)
        if opt.AppName == "" {
                opt.AppName = optU.appName
        }
        for name, conf := range confs {
                addInstance(ctx, name, conf, opt)
        }

        return func() {
                rwlock.Lock()
                defer rwlock.Unlock()

                pid := syscall.Getpid()
                app := config.Use(opt.AppName).AppName()
                if appInstances != nil {
                        for name, instance := range appInstances[opt.AppName] {
                                if err := instance.GetProxy().Disconnect(nil); err != nil {
                                        log.Printf("%v [Gofusion] %s %s %s disconnect error: %s",
                                                pid, app, config.ComponentMongo, name, err)
                                }
                        }
                        delete(appInstances, opt.AppName)
                }
        }
}

func @160:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mongo/metrics.go:

func(evt *event.PoolEvent) {
                switch evt.Type {
                case event.PoolCreated:
                case event.PoolReady:
                case event.PoolCleared:
                case event.PoolClosedEvent:
                case event.ConnectionCreated:
                        total.Add(1)
                case event.ConnectionReady:
                case event.ConnectionClosed:
                        total.Add(-1)
                case event.GetStarted:
                case event.GetFailed:
                case event.GetSucceeded:
                        inuse.Add(1)
                case event.ConnectionReturned:
                        inuse.Add(-1)
                }
        }

func @59:25

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mongo/metrics.go:

func() {
                        metricsPoolLocker.RLock()
                        defer metricsPoolLocker.RUnlock()
                        inuse = metricsPoolInUseCounter[appName][name].Load()
                        total = metricsPoolTotalCounter[appName][name].Load()
                }

func @83:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mongo/mongo.go:

83	`func(o *useOption) {`
84	`o.writeConcern = writeConcern`
85	`}`

func init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mongo/construct.go:

97	`func init() {`
98	`config.AddComponent(config.ComponentMongo, Construct)`
99	`}`

func metricMongoStats

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mongo/metrics.go:

func metricMongoStats(ctx context.Context, appName, name string, labels []metrics.Label) {
        _, _ = utils.Catch(func() {
                var total, inuse int64
                _, err := utils.Catch(func() {
                        metricsPoolLocker.RLock()
                        defer metricsPoolLocker.RUnlock()
                        inuse = metricsPoolInUseCounter[appName][name].Load()
                        total = metricsPoolTotalCounter[appName][name].Load()
                })
                if err != nil {
                        return
                }

                app := config.Use(appName).AppName()
                idleKey := append([]string{app}, metricsPoolIdleKey...)
                inuseKey := append([]string{app}, metricsPoolInUseKey...)
                totalKey := append([]string{app}, metricsPoolTotalKey...)
                ide := total - inuse
                for _, m := range metrics.Internal(metrics.AppName(appName)) {
                        select {
                        case <-ctx.Done():
                                return
                        default:
                                if m.IsEnableServiceLabel() {
                                        m.SetGauge(ctx, idleKey, float64(ide), metrics.Labels(labels))
                                        m.SetGauge(ctx, inuseKey, float64(inuse), metrics.Labels(labels))
                                        m.SetGauge(ctx, totalKey, float64(total), metrics.Labels(labels))
                                } else {
                                        m.SetGauge(ctx, metricsPoolIdleKey, float64(ide), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsPoolInUseKey, float64(inuse), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsPoolTotalKey, float64(total), metrics.Labels(labels))
                                }
                        }
                }
        })
}

func AppName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mongo/mongo.go:

func AppName(name string) utils.OptionFunc[useOption] {
        return func(o *useOption) {
                o.appName = name
        }
}

func WriteConcern

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mongo/mongo.go:

func WriteConcern(writeConcern *writeconcern.WriteConcern) utils.OptionFunc[useOption] {
        return func(o *useOption) {
                o.writeConcern = writeConcern
        }
}

func @72:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mongo/mongo.go:

72	`func(o *useOption) {`
73	`o.appName = name`
74	`}`

func instance.GetProxy

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mongo/mongo.go:

30	`func (d instance) GetProxy() mgoDrv.Client {`
31	`return d.mongo.GetProxy()`
32	`}`

func instance.Database

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mongo/mongo.go:

34	`func (d instance) Database(opts ...options.DatabaseOptions) *mgoDrv.Database {`
35	`return d.mongo.Database(d.database, opts...)`
36	`}`

func addInstance

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mongo/construct.go:

func addInstance(ctx context.Context, name string, conf *Conf, opt *config.InitOption) {
        var monitor *mgoEvt.CommandMonitor
        if utils.IsStrNotBlank(conf.LoggerConfig.Logger) {
                loggerType := inspect.TypeOf(conf.LoggerConfig.Logger)
                loggerValue := reflect.New(loggerType)
                if loggerValue.Type().Implements(customLoggerType) {
                        l := fusLog.Use(conf.LoggerConfig.LogInstance, fusLog.AppName(opt.AppName))
                        loggerValue.Interface().(customLogger).Init(l, opt.AppName, name)
                }
                monitor = loggerValue.Interface().(logger).GetMonitor()
        }

        // conf.Option.Password = config.CryptoDecryptFunc()(conf.Option.Password)
        mgoCli, err := mongo.Default.New(ctx, conf.Option,
                mongo.WithMonitor(monitor),
                mongo.WithPoolMonitor(&mgoEvt.PoolMonitor{Event: metricsPoolMonitor(opt.AppName, name)}))
        if err != nil {
                panic(err)
        }

        rwlock.Lock()
        defer rwlock.Unlock()
        if appInstances == nil {
                appInstances = make(map[string]map[string]*instance)
        }
        if appInstances[opt.AppName] == nil {
                appInstances[opt.AppName] = make(map[string]*instance)
        }
        if _, ok := appInstances[opt.AppName][name]; ok {
                panic(ErrDuplicatedName)
        }
        appInstances[opt.AppName][name] = &instance{mongo: mgoCli, name: name, database: conf.DB}

        // ioc
        if opt.DI != nil {
                opt.DI.MustProvide(
                        func() *mgoDrv.Database {
                                return Use(name, AppName(opt.AppName)).Database
                        },
                        di.Name(name),
                )
        }

        go startDaemonRoutines(ctx, opt.AppName, name, conf)
}

func @33:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mongo/construct.go:

func() {
                rwlock.Lock()
                defer rwlock.Unlock()

                pid := syscall.Getpid()
                app := config.Use(opt.AppName).AppName()
                if appInstances != nil {
                        for name, instance := range appInstances[opt.AppName] {
                                if err := instance.GetProxy().Disconnect(nil); err != nil {
                                        log.Printf("%v [Gofusion] %s %s %s disconnect error: %s",
                                                pid, app, config.ComponentMongo, name, err)
                                }
                        }
                        delete(appInstances, opt.AppName)
                }
        }

func Use

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mongo/mongo.go:

func Use(name string, opts ...utils.OptionExtender) *Mongo {
        opt := utils.ApplyOptions[useOption](opts...)
        dbOpt := options.
                Database().
                SetReadConcern(opt.readConcern).
                SetWriteConcern(opt.writeConcern).
                SetReadPreference(opt.readPreference).
                SetBSONOptions(opt.bsonOptions).
                SetRegistry(opt.registry)

        rwlock.RLock()
        defer rwlock.RUnlock()
        instances, ok := appInstances[opt.appName]
        if !ok {
                panic(fmt.Errorf("mongo database instance not found for app: %s", opt.appName))
        }
        instance, ok := instances[name]
        if !ok {
                panic(fmt.Errorf("mongo database instance not found for name: %s", name))
        }
        return &Mongo{Database: instance.Database(dbOpt), Name: name}
}

func metricMongoLatency

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mongo/metrics.go:

func metricMongoLatency(ctx context.Context, appName, name string, labels []metrics.Label) {
        select {
        case <-ctx.Done():
                return
        default:

        }

        _, _ = utils.Catch(func() {
                rwlock.RLock()
                defer rwlock.RUnlock()
                instances, ok := appInstances[appName]
                if !ok {
                        return
                }
                instance, ok := instances[name]
                if !ok {
                        return
                }

                mgoCli := instance.GetProxy()
                begin := time.Now()
                if err := mgoCli.Ping(ctx, nil); err != nil {
                        return
                }

                latency := float64(time.Since(begin)) / float64(time.Millisecond)
                latencyKey := append([]string{config.Use(appName).AppName()}, metricsLatencyKey...)
                for _, m := range metrics.Internal(metrics.AppName(appName)) {
                        select {
                        case <-ctx.Done():
                                return
                        default:
                                if m.IsEnableServiceLabel() {
                                        m.AddSample(ctx, latencyKey, latency,
                                                metrics.Labels(labels),
                                                metrics.PrometheusBuckets(metricsLatencyBuckets),
                                        )
                                } else {
                                        m.AddSample(ctx, metricsLatencyKey, latency,
                                                metrics.Labels(labels),
                                                metrics.PrometheusBuckets(metricsLatencyBuckets),
                                        )
                                }
                        }
                }
        })
}

func @101:21

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mongo/metrics.go:

func() {
                rwlock.RLock()
                defer rwlock.RUnlock()
                instances, ok := appInstances[appName]
                if !ok {
                        return
                }
                instance, ok := instances[name]
                if !ok {
                        return
                }

                mgoCli := instance.GetProxy()
                begin := time.Now()
                if err := mgoCli.Ping(ctx, nil); err != nil {
                        return
                }

                latency := float64(time.Since(begin)) / float64(time.Millisecond)
                latencyKey := append([]string{config.Use(appName).AppName()}, metricsLatencyKey...)
                for _, m := range metrics.Internal(metrics.AppName(appName)) {
                        select {
                        case <-ctx.Done():
                                return
                        default:
                                if m.IsEnableServiceLabel() {
                                        m.AddSample(ctx, latencyKey, latency,
                                                metrics.Labels(labels),
                                                metrics.PrometheusBuckets(metricsLatencyBuckets),
                                        )
                                } else {
                                        m.AddSample(ctx, metricsLatencyKey, latency,
                                                metrics.Labels(labels),
                                                metrics.PrometheusBuckets(metricsLatencyBuckets),
                                        )
                                }
                        }
                }
        }

func @57:21

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mongo/metrics.go:

func() {
                var total, inuse int64
                _, err := utils.Catch(func() {
                        metricsPoolLocker.RLock()
                        defer metricsPoolLocker.RUnlock()
                        inuse = metricsPoolInUseCounter[appName][name].Load()
                        total = metricsPoolTotalCounter[appName][name].Load()
                })
                if err != nil {
                        return
                }

                app := config.Use(appName).AppName()
                idleKey := append([]string{app}, metricsPoolIdleKey...)
                inuseKey := append([]string{app}, metricsPoolInUseKey...)
                totalKey := append([]string{app}, metricsPoolTotalKey...)
                ide := total - inuse
                for _, m := range metrics.Internal(metrics.AppName(appName)) {
                        select {
                        case <-ctx.Done():
                                return
                        default:
                                if m.IsEnableServiceLabel() {
                                        m.SetGauge(ctx, idleKey, float64(ide), metrics.Labels(labels))
                                        m.SetGauge(ctx, inuseKey, float64(inuse), metrics.Labels(labels))
                                        m.SetGauge(ctx, totalKey, float64(total), metrics.Labels(labels))
                                } else {
                                        m.SetGauge(ctx, metricsPoolIdleKey, float64(ide), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsPoolInUseKey, float64(inuse), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsPoolTotalKey, float64(total), metrics.Labels(labels))
                                }
                        }
                }
        }

func @87:4

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mongo/construct.go:

87	`func() *mgoDrv.Database {`
88	`return Use(name, AppName(opt.AppName)).Database`
89	`}`

func ReadConcern

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mongo/mongo.go:

func ReadConcern(readConcern *readconcern.ReadConcern) utils.OptionFunc[useOption] {
        return func(o *useOption) {
                o.readConcern = readConcern
        }
}

func @78:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mongo/mongo.go:

78	`func(o *useOption) {`
79	`o.readConcern = readConcern`
80	`}`

func @88:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mongo/mongo.go:

88	`func(o *useOption) {`
89	`o.readPreference = readPreference`
90	`}`

func BsonOptions

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mongo/mongo.go:

func BsonOptions(bsonOptions *options.BSONOptions) utils.OptionFunc[useOption] {
        return func(o *useOption) {
                o.bsonOptions = bsonOptions
        }
}

func @93:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mongo/mongo.go:

93	`func(o *useOption) {`
94	`o.bsonOptions = bsonOptions`
95	`}`

func Registry

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mongo/mongo.go:

func Registry(registry *bsoncodec.Registry) utils.OptionFunc[useOption] {
        return func(o *useOption) {
                o.registry = registry
        }
}

func @98:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mongo/mongo.go:

98	`func(o *useOption) {`
99	`o.registry = registry`
100	`}`

func ReadPreference

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mongo/mongo.go:

func ReadPreference(readPreference *readpref.ReadPref) utils.OptionFunc[useOption] {
        return func(o *useOption) {
                o.readPreference = readPreference
        }
}

Package Overview: github.com/wfusion/gofusion/mq 62.1%

Please select a function to see what's left for testing.

`NewEventSubscriber(...)`	`github.com/wfusion/gofusion/mq/event.go`	`100.0%`	`9/9`
`router.Handle(...)`	`github.com/wfusion/gofusion/mq/router.go`	`100.0%`	`7/7`
`newGoChannel(...)`	`github.com/wfusion/gofusion/mq/gochannel.go`	`100.0%`	`7/7`
`newPostgres(...)`	`github.com/wfusion/gofusion/mq/postgres.go`	`100.0%`	`7/7`
`Construct(...)`	`github.com/wfusion/gofusion/mq/construct.go`	`100.0%`	`7/7`
`newMysql(...)`	`github.com/wfusion/gofusion/mq/mysql.go`	`100.0%`	`7/7`
`newRedis(...)`	`github.com/wfusion/gofusion/mq/redis.go`	`100.0%`	`6/6`
`router.runEventHandlers(...)`	`github.com/wfusion/gofusion/mq/router.go`	`100.0%`	`6/6`
`eventSubscriber[T].SubscribeEvent(...)`	`github.com/wfusion/gofusion/mq/event.go`	`100.0%`	`5/5`
`newAMQP(...)`	`github.com/wfusion/gofusion/mq/amqp.go`	`100.0%`	`5/5`
`newKafka(...)`	`github.com/wfusion/gofusion/mq/kafka.go`	`100.0%`	`5/5`
`newPulsar(...)`	`github.com/wfusion/gofusion/mq/pulsar.go`	`100.0%`	`5/5`
`newSub(...)`	`github.com/wfusion/gofusion/mq/mq.go`	`100.0%`	`4/4`
`NewEventPublisher(...)`	`github.com/wfusion/gofusion/mq/event.go`	`100.0%`	`4/4`
`newPub(...)`	`github.com/wfusion/gofusion/mq/mq.go`	`100.0%`	`4/4`
`messageConvertTo(...)`	`github.com/wfusion/gofusion/mq/mq.go`	`100.0%`	`2/2`
`isEventHandler(...)`	`github.com/wfusion/gofusion/mq/event.go`	`100.0%`	`2/2`
`@182:9(...)`	`github.com/wfusion/gofusion/mq/types.go`	`100.0%`	`1/1`
`init(...)`	`github.com/wfusion/gofusion/mq/construct.go`	`100.0%`	`1/1`
`abstractMQ.watermillSubscriber(...)`	`github.com/wfusion/gofusion/mq/mq.go`	`100.0%`	`1/1`
`mysqlPublisher.close(...)`	`github.com/wfusion/gofusion/mq/mysql.go`	`100.0%`	`1/1`
`EventHandler(...)`	`github.com/wfusion/gofusion/mq/event.go`	`100.0%`	`1/1`
`@48:9(...)`	`github.com/wfusion/gofusion/mq/event.go`	`100.0%`	`1/1`
`EventHandlerWithMsg(...)`	`github.com/wfusion/gofusion/mq/event.go`	`100.0%`	`1/1`
`@55:9(...)`	`github.com/wfusion/gofusion/mq/event.go`	`100.0%`	`1/1`
`@172:9(...)`	`github.com/wfusion/gofusion/mq/types.go`	`100.0%`	`1/1`
`Events(...)`	`github.com/wfusion/gofusion/mq/types.go`	`100.0%`	`1/1`
`@42:31(...)`	`github.com/wfusion/gofusion/mq/mysql.go`	`100.0%`	`1/1`
`event[T].ID(...)`	`github.com/wfusion/gofusion/mq/event.go`	`100.0%`	`1/1`
`@161:9(...)`	`github.com/wfusion/gofusion/mq/types.go`	`100.0%`	`1/1`
`messages(...)`	`github.com/wfusion/gofusion/mq/types.go`	`100.0%`	`1/1`
`ChannelLen(...)`	`github.com/wfusion/gofusion/mq/types.go`	`100.0%`	`1/1`
`@179:9(...)`	`github.com/wfusion/gofusion/mq/construct.go`	`100.0%`	`1/1`
`@158:9(...)`	`github.com/wfusion/gofusion/mq/types.go`	`100.0%`	`1/1`
`Messages(...)`	`github.com/wfusion/gofusion/mq/types.go`	`100.0%`	`1/1`
`UntimedEvent(...)`	`github.com/wfusion/gofusion/mq/event.go`	`100.0%`	`1/1`
`AppName(...)`	`github.com/wfusion/gofusion/mq/construct.go`	`100.0%`	`1/1`
`router.close(...)`	`github.com/wfusion/gofusion/mq/router.go`	`100.0%`	`1/1`
`abstractMQ.topic(...)`	`github.com/wfusion/gofusion/mq/mq.go`	`100.0%`	`1/1`
`newEvent(...)`	`github.com/wfusion/gofusion/mq/event.go`	`100.0%`	`1/1`
`@80:31(...)`	`github.com/wfusion/gofusion/mq/mysql.go`	`100.0%`	`1/1`
`event[T].Type(...)`	`github.com/wfusion/gofusion/mq/event.go`	`100.0%`	`1/1`
`event[T].Payload(...)`	`github.com/wfusion/gofusion/mq/event.go`	`100.0%`	`1/1`
`@86:38(...)`	`github.com/wfusion/gofusion/mq/mysql.go`	`100.0%`	`1/1`
`handleEventSubscriber(...)`	`github.com/wfusion/gofusion/mq/types.go`	`100.0%`	`1/1`
`router.addEventDispatchHandler(...)`	`github.com/wfusion/gofusion/mq/router.go`	`100.0%`	`1/1`
`event[T].Context(...)`	`github.com/wfusion/gofusion/mq/event.go`	`100.0%`	`1/1`
`@192:9(...)`	`github.com/wfusion/gofusion/mq/types.go`	`100.0%`	`1/1`
`rawMessageConvertFrom(...)`	`github.com/wfusion/gofusion/mq/mq.go`	`100.0%`	`1/1`
`NewMessage(...)`	`github.com/wfusion/gofusion/mq/types.go`	`100.0%`	`1/1`
`_AMQPSubscriber.close(...)`	`github.com/wfusion/gofusion/mq/amqp.go`	`100.0%`	`1/1`
`goChannel.close(...)`	`github.com/wfusion/gofusion/mq/gochannel.go`	`100.0%`	`1/1`
`message.ID(...)`	`github.com/wfusion/gofusion/mq/types.go`	`100.0%`	`1/1`
`@42:31(...)`	`github.com/wfusion/gofusion/mq/postgres.go`	`100.0%`	`1/1`
`kafkaPublisher.close(...)`	`github.com/wfusion/gofusion/mq/kafka.go`	`100.0%`	`1/1`
`postgresPublisher.close(...)`	`github.com/wfusion/gofusion/mq/postgres.go`	`100.0%`	`1/1`
`kafkaSubscriber.close(...)`	`github.com/wfusion/gofusion/mq/kafka.go`	`100.0%`	`1/1`
`@80:31(...)`	`github.com/wfusion/gofusion/mq/postgres.go`	`100.0%`	`1/1`
`redisSubscriber.close(...)`	`github.com/wfusion/gofusion/mq/redis.go`	`100.0%`	`1/1`
`@86:38(...)`	`github.com/wfusion/gofusion/mq/postgres.go`	`100.0%`	`1/1`
`redisPublisher.close(...)`	`github.com/wfusion/gofusion/mq/redis.go`	`100.0%`	`1/1`
`abstractMQ.watermillPublisher(...)`	`github.com/wfusion/gofusion/mq/mq.go`	`100.0%`	`1/1`
`postgresSubscriber.close(...)`	`github.com/wfusion/gofusion/mq/postgres.go`	`100.0%`	`1/1`
`_AMQPPublisher.close(...)`	`github.com/wfusion/gofusion/mq/amqp.go`	`100.0%`	`1/1`
`pulsarSubscriber.close(...)`	`github.com/wfusion/gofusion/mq/pulsar.go`	`100.0%`	`1/1`
`message.Payload(...)`	`github.com/wfusion/gofusion/mq/types.go`	`100.0%`	`1/1`
`router.Running(...)`	`github.com/wfusion/gofusion/mq/router.go`	`100.0%`	`1/1`
`pulsarPublisher.close(...)`	`github.com/wfusion/gofusion/mq/pulsar.go`	`100.0%`	`1/1`
`mysqlSubscriber.close(...)`	`github.com/wfusion/gofusion/mq/mysql.go`	`100.0%`	`1/1`
`@395:6(...)`	`github.com/wfusion/gofusion/mq/router.go`	`92.9%`	`13/14`
`eventPublisher[T].PublishEvent(...)`	`github.com/wfusion/gofusion/mq/event.go`	`91.7%`	`11/12`
`router.handleEvent(...)`	`github.com/wfusion/gofusion/mq/router.go`	`89.5%`	`17/19`
`@41:9(...)`	`github.com/wfusion/gofusion/mq/construct.go`	`88.0%`	`22/25`
`@370:3(...)`	`github.com/wfusion/gofusion/mq/router.go`	`86.2%`	`25/29`
`formatEventHandlerSignature(...)`	`github.com/wfusion/gofusion/mq/event.go`	`85.7%`	`6/7`
`@278:5(...)`	`github.com/wfusion/gofusion/mq/router.go`	`85.7%`	`6/7`
`abstractMQ.SubscribeRaw(...)`	`github.com/wfusion/gofusion/mq/mq.go`	`85.7%`	`6/7`
`addInstance(...)`	`github.com/wfusion/gofusion/mq/construct.go`	`84.1%`	`37/44`
`router.isHandlerConflict(...)`	`github.com/wfusion/gofusion/mq/router.go`	`83.3%`	`5/6`
`Sub(...)`	`github.com/wfusion/gofusion/mq/construct.go`	`80.0%`	`8/10`
`Pub(...)`	`github.com/wfusion/gofusion/mq/construct.go`	`80.0%`	`8/10`
`Use(...)`	`github.com/wfusion/gofusion/mq/construct.go`	`80.0%`	`8/10`
`newRedisPublisher(...)`	`github.com/wfusion/gofusion/mq/redis.go`	`80.0%`	`4/5`
`newMysqlSubscriber(...)`	`github.com/wfusion/gofusion/mq/mysql.go`	`80.0%`	`4/5`
`newPostgresPublisher(...)`	`github.com/wfusion/gofusion/mq/postgres.go`	`80.0%`	`4/5`
`newKafkaPublisher(...)`	`github.com/wfusion/gofusion/mq/kafka.go`	`80.0%`	`4/5`
`router.Start(...)`	`github.com/wfusion/gofusion/mq/router.go`	`80.0%`	`4/5`
`newRedisSubscriber(...)`	`github.com/wfusion/gofusion/mq/redis.go`	`80.0%`	`4/5`
`newMysqlPublisher(...)`	`github.com/wfusion/gofusion/mq/mysql.go`	`80.0%`	`4/5`
`newPostgresSubscriber(...)`	`github.com/wfusion/gofusion/mq/postgres.go`	`80.0%`	`4/5`
`newAMQPPublisher(...)`	`github.com/wfusion/gofusion/mq/amqp.go`	`78.6%`	`11/14`
`newAMQPSubscriber(...)`	`github.com/wfusion/gofusion/mq/amqp.go`	`78.6%`	`11/14`
`newRouter(...)`	`github.com/wfusion/gofusion/mq/router.go`	`75.0%`	`18/24`
`newPulsarPublisher(...)`	`github.com/wfusion/gofusion/mq/pulsar.go`	`75.0%`	`9/12`
`abstractMQ.PublishRaw(...)`	`github.com/wfusion/gofusion/mq/mq.go`	`71.4%`	`10/14`
`newKafkaSubscriber(...)`	`github.com/wfusion/gofusion/mq/kafka.go`	`71.4%`	`5/7`
`abstractMQ.newObjectMessage(...)`	`github.com/wfusion/gofusion/mq/mq.go`	`66.7%`	`8/12`
`router.run(...)`	`github.com/wfusion/gofusion/mq/router.go`	`66.7%`	`4/6`
`event[T].Ack(...)`	`github.com/wfusion/gofusion/mq/event.go`	`66.7%`	`2/3`
`parseKafkaConf(...)`	`github.com/wfusion/gofusion/mq/kafka.go`	`64.0%`	`16/25`
`messageConvertFrom(...)`	`github.com/wfusion/gofusion/mq/mq.go`	`63.6%`	`7/11`
`newPulsarSubscriber(...)`	`github.com/wfusion/gofusion/mq/pulsar.go`	`60.0%`	`9/15`
`parseAMQPEndpoint(...)`	`github.com/wfusion/gofusion/mq/amqp.go`	`54.5%`	`6/11`
`@146:13(...)`	`github.com/wfusion/gofusion/mq/mq.go`	`46.7%`	`7/15`
`router.addHandler(...)`	`github.com/wfusion/gofusion/mq/router.go`	`45.5%`	`5/11`
`abstractMQ.Publish(...)`	`github.com/wfusion/gofusion/mq/mq.go`	`36.8%`	`7/19`
`@129:26(...)`	`github.com/wfusion/gofusion/mq/event.go`	`25.0%`	`3/12`
`@188:13(...)`	`github.com/wfusion/gofusion/mq/mq.go`	`0.0%`	`0/25`
`setParams(...)`	`github.com/wfusion/gofusion/mq/utils.go`	`0.0%`	`0/12`
`formatFields(...)`	`github.com/wfusion/gofusion/mq/log.go`	`0.0%`	`0/10`
`sub(...)`	`github.com/wfusion/gofusion/mq/construct.go`	`0.0%`	`0/10`
`router.Serve(...)`	`github.com/wfusion/gofusion/mq/router.go`	`0.0%`	`0/8`
`wrapParams(...)`	`github.com/wfusion/gofusion/mq/utils.go`	`0.0%`	`0/7`
`abstractMQ.newMessage(...)`	`github.com/wfusion/gofusion/mq/mq.go`	`0.0%`	`0/7`
`abstractMQ.Subscribe(...)`	`github.com/wfusion/gofusion/mq/mq.go`	`0.0%`	`0/7`
`@340:9(...)`	`github.com/wfusion/gofusion/mq/router.go`	`0.0%`	`0/6`
`@117:19(...)`	`github.com/wfusion/gofusion/mq/mq.go`	`0.0%`	`0/5`
`@78:19(...)`	`github.com/wfusion/gofusion/mq/mq.go`	`0.0%`	`0/5`
`@113:18(...)`	`github.com/wfusion/gofusion/mq/router.go`	`0.0%`	`0/5`
`event[T].toTime(...)`	`github.com/wfusion/gofusion/mq/event.go`	`0.0%`	`0/5`
`@220:4(...)`	`github.com/wfusion/gofusion/mq/router.go`	`0.0%`	`0/4`
`event[T].Nack(...)`	`github.com/wfusion/gofusion/mq/event.go`	`0.0%`	`0/3`
`@120:16(...)`	`github.com/wfusion/gofusion/mq/mq.go`	`0.0%`	`0/3`
`@150:9(...)`	`github.com/wfusion/gofusion/mq/types.go`	`0.0%`	`0/3`
`@81:16(...)`	`github.com/wfusion/gofusion/mq/mq.go`	`0.0%`	`0/3`
`router.handle(...)`	`github.com/wfusion/gofusion/mq/router.go`	`0.0%`	`0/3`
`unwrapParams(...)`	`github.com/wfusion/gofusion/mq/utils.go`	`0.0%`	`0/3`
`@166:9(...)`	`github.com/wfusion/gofusion/mq/types.go`	`0.0%`	`0/2`
`@252:5(...)`	`github.com/wfusion/gofusion/mq/router.go`	`0.0%`	`0/2`
`@264:5(...)`	`github.com/wfusion/gofusion/mq/router.go`	`0.0%`	`0/2`
`formatLogMsg(...)`	`github.com/wfusion/gofusion/mq/log.go`	`0.0%`	`0/2`
`event[T].DeletedAt(...)`	`github.com/wfusion/gofusion/mq/event.go`	`0.0%`	`0/1`
`logDebug(...)`	`github.com/wfusion/gofusion/mq/log.go`	`0.0%`	`0/1`
`@79:38(...)`	`github.com/wfusion/gofusion/mq/mq.go`	`0.0%`	`0/1`
`@118:38(...)`	`github.com/wfusion/gofusion/mq/mq.go`	`0.0%`	`0/1`
`@133:19(...)`	`github.com/wfusion/gofusion/mq/router.go`	`0.0%`	`0/1`
`event[T].UpdatedAt(...)`	`github.com/wfusion/gofusion/mq/event.go`	`0.0%`	`0/1`
`event[T].CreatedAt(...)`	`github.com/wfusion/gofusion/mq/event.go`	`0.0%`	`0/1`
`EventDeleted(...)`	`github.com/wfusion/gofusion/mq/event.go`	`0.0%`	`0/1`
`EventUpdated(...)`	`github.com/wfusion/gofusion/mq/event.go`	`0.0%`	`0/1`
`Objects(...)`	`github.com/wfusion/gofusion/mq/types.go`	`0.0%`	`0/1`
`EventCreated(...)`	`github.com/wfusion/gofusion/mq/event.go`	`0.0%`	`0/1`
`NewEvent(...)`	`github.com/wfusion/gofusion/mq/event.go`	`0.0%`	`0/1`
`@150:17(...)`	`github.com/wfusion/gofusion/mq/construct.go`	`0.0%`	`0/1`
`@102:9(...)`	`github.com/wfusion/gofusion/mq/event.go`	`0.0%`	`0/1`
`NewEventSubscriberDI(...)`	`github.com/wfusion/gofusion/mq/event.go`	`0.0%`	`0/1`
`Async(...)`	`github.com/wfusion/gofusion/mq/types.go`	`0.0%`	`0/1`
`@130:20(...)`	`github.com/wfusion/gofusion/mq/router.go`	`0.0%`	`0/1`
`@62:9(...)`	`github.com/wfusion/gofusion/mq/event.go`	`0.0%`	`0/1`
`NewEventPublisherDI(...)`	`github.com/wfusion/gofusion/mq/event.go`	`0.0%`	`0/1`
`@77:18(...)`	`github.com/wfusion/gofusion/mq/router.go`	`0.0%`	`0/1`
`@169:23(...)`	`github.com/wfusion/gofusion/mq/construct.go`	`0.0%`	`0/1`
`kafkaOAuthProvider.Token(...)`	`github.com/wfusion/gofusion/mq/kafka.go`	`0.0%`	`0/1`
`@149:17(...)`	`github.com/wfusion/gofusion/mq/construct.go`	`0.0%`	`0/1`
`abstractMQ.close(...)`	`github.com/wfusion/gofusion/mq/mq.go`	`0.0%`	`0/1`
`abstractMQ.watermillLogger(...)`	`github.com/wfusion/gofusion/mq/mq.go`	`0.0%`	`0/1`
`logError(...)`	`github.com/wfusion/gofusion/mq/log.go`	`0.0%`	`0/1`
`message.RawMessage(...)`	`github.com/wfusion/gofusion/mq/types.go`	`0.0%`	`0/1`
`message.Object(...)`	`github.com/wfusion/gofusion/mq/types.go`	`0.0%`	`0/1`
`logInfo(...)`	`github.com/wfusion/gofusion/mq/log.go`	`0.0%`	`0/1`
`logTrace(...)`	`github.com/wfusion/gofusion/mq/log.go`	`0.0%`	`0/1`
`@93:29(...)`	`github.com/wfusion/gofusion/mq/router.go`	`0.0%`	`0/1`

func NewEventSubscriber

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

func NewEventSubscriber[T eventual](name string, opts ...utils.OptionExtender) EventSubscriber[T] {
        opt := utils.ApplyOptions[useOption](opts...)
        subscriber := Sub(name, AppName(opt.appName))
        abstractMq := inspect.GetField[*abstractMQ](subscriber, "abstractMQ")

        var m reflect.Value
        for tv := reflect.ValueOf(new(T)); tv.Kind() == reflect.Ptr; tv = tv.Elem() {
                if m = tv.MethodByName("EventType"); m.IsValid() {
                        break
                }
        }
        eventType := m.Call(nil)[0].String()
        return &eventSubscriber[T]{abstractMQ: abstractMq, evtType: eventType}
}

func router.Handle

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/router.go:

func (r *router) Handle(handlerName string, hdr any, opts ...utils.OptionExtender) {
        opt := utils.ApplyOptions[routerOption](opts...)
        if opt.isEventSubscriber || singleConsumerMQType.Contains(r.c.Type) {
                r.addHandler(handlerName, handlerName, hdr, opt)
                return
        }
        for i := 0; i < r.c.ConsumerConcurrency; i++ {
                consumerName := fmt.Sprintf("%s_%v", handlerName, i)
                r.addHandler(handlerName, consumerName, hdr, opt)
        }
}

func newGoChannel

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/gochannel.go:

func newGoChannel(ctx context.Context, appName, name string, conf *Conf, logger watermill.LoggerAdapter) (
        pub Publisher, sub Subscriber) {
        cfg := gochannel.Config{
                OutputChannelBuffer:            int64(conf.ConsumerConcurrency),
                Persistent:                     conf.Persistent,
                ConsumerGroup:                  conf.ConsumerGroup,
                BlockPublishUntilSubscriberAck: false,
                AppID:                          config.Use(appName).AppName(),
        }

        native := gochannel.NewGoChannel(cfg, logger)
        if conf.Producer {
                pub = &goChannel{
                        abstractMQ: newPub(ctx, native, appName, name, conf, logger),
                        ch:         native,
                }
        }

        if conf.Consumer {
                sub = &goChannel{
                        abstractMQ: newSub(ctx, native, appName, name, conf, logger),
                        ch:         native,
                }
        }
        return
}

func newPostgres

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/postgres.go:

func newPostgres(ctx context.Context, appName, name string, conf *Conf, logger watermill.LoggerAdapter) (
        pub Publisher, sub Subscriber) {
        instance := db.Use(ctx, conf.Endpoint.Instance, db.AppName(appName))
        cli := utils.Must(instance.GetProxy().DB())
        if conf.Producer {
                pub = newPostgresPublisher(ctx, appName, name, conf, logger, cli)
        }

        if conf.Consumer {
                sub = newPostgresSubscriber(ctx, appName, name, conf, logger, cli)
        }

        return
}

func Construct

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/construct.go:

func Construct(ctx context.Context, confs map[string]*Conf, opts ...utils.OptionExtender) func() {
        opt := utils.ApplyOptions[config.InitOption](opts...)
        optU := utils.ApplyOptions[useOption](opts...)
        if opt.AppName == "" {
                opt.AppName = optU.appName
        }

        for name, conf := range confs {
                addInstance(ctx, name, conf, opt)
        }

        return func() {
                locker.Lock()
                defer locker.Unlock()

                pid := syscall.Getpid()
                app := config.Use(opt.AppName).AppName()
                if routers != nil {
                        for name, router := range routers[opt.AppName] {
                                log.Printf("%v [Gofusion] %s %s %s router exiting...",
                                        pid, app, config.ComponentMessageQueue, name)
                                if err := router.close(); err == nil {
                                        log.Printf("%v [Gofusion] %s %s %s router exited",
                                                pid, app, config.ComponentMessageQueue, name)
                                } else {
                                        log.Printf("%v [Gofusion] %s %s %s router exit failed: %s",
                                                pid, app, config.ComponentMessageQueue, name, err)
                                }
                        }
                        delete(routers, opt.AppName)
                }

                if publishers != nil {
                        for name, publisher := range publishers[opt.AppName] {
                                log.Printf("%v [Gofusion] %s %s %s publisher exiting...",
                                        pid, app, config.ComponentMessageQueue, name)
                                if err := publisher.close(); err == nil {
                                        log.Printf("%v [Gofusion] %s %s %s publisher exited",
                                                pid, app, config.ComponentMessageQueue, name)
                                } else {
                                        log.Printf("%v [Gofusion] %s %s %s publisher exit failed: %s",
                                                pid, app, config.ComponentMessageQueue, name, err)
                                }
                        }
                        delete(publishers, opt.AppName)
                }

                if subscribers != nil {
                        for name, subscriber := range subscribers[opt.AppName] {
                                log.Printf("%v [Gofusion] %s %s %s subscriber exiting...",
                                        pid, app, config.ComponentMessageQueue, name)
                                if err := subscriber.close(); err == nil {
                                        log.Printf("%v [Gofusion] %s %s %s subscriber exited",
                                                pid, app, config.ComponentMessageQueue, name)
                                } else {
                                        log.Printf("%v [Gofusion] %s %s %s subscriber exit failed: %s",
                                                pid, app, config.ComponentMessageQueue, name, err)
                                }
                        }
                        delete(subscribers, opt.AppName)
                }
        }
}

func newMysql

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mysql.go:

func newMysql(ctx context.Context, appName, name string, conf *Conf, logger watermill.LoggerAdapter) (
        pub Publisher, sub Subscriber) {
        instance := db.Use(ctx, conf.Endpoint.Instance, db.AppName(appName))
        cli := utils.Must(instance.GetProxy().DB())
        if conf.Producer {
                pub = newMysqlPublisher(ctx, appName, name, conf, logger, cli)
        }

        if conf.Consumer {
                sub = newMysqlSubscriber(ctx, appName, name, conf, logger, cli)
        }

        return
}

func newRedis

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/redis.go:

func newRedis(ctx context.Context, appName, name string, conf *Conf, logger watermill.LoggerAdapter) (
        pub Publisher, sub Subscriber) {

        cli := redis.Use(ctx, conf.Endpoint.Instance, redis.AppName(appName))

        if conf.Producer {
                pub = newRedisPublisher(ctx, appName, name, conf, logger, cli)
        }

        if conf.Consumer {
                sub = newRedisSubscriber(ctx, appName, name, conf, logger, cli)
        }

        return
}

func router.runEventHandlers

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/router.go:

func (r *router) runEventHandlers() {
        if singleConsumerMQType.Contains(r.c.Type) {
                r.addEventDispatchHandler(defaultRouterEventHandlerName)
                return
        }
        for i := 0; i < r.c.ConsumerConcurrency; i++ {
                consumerName := fmt.Sprintf("%s_%v", defaultRouterEventHandlerName, i)
                r.addEventDispatchHandler(consumerName)
        }
}

func eventSubscriber[T].SubscribeEvent

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

func (e *eventSubscriber[T]) SubscribeEvent(ctx context.Context, opts ...utils.OptionExtender) (
        dst <-chan Event[T], err error) {
        opt := utils.ApplyOptions[subOption](opts...)
        out := make(chan Event[T], opt.channelLength)
        r := Use(e.name, AppName(e.appName)).(*router)
        r.Handle(
                e.evtType,
                EventHandlerWithMsg[T](func(ctx context.Context, event Event[T]) (msgs []Message, err error) {
                        select {
                        case out <- event:
                        case <-r.Router.ClosingInProgressCh:
                                event.Nack()
                                e.logger.Info(fmt.Sprintf("event subscriber %s exited", e.name), nil)
                                return
                        case <-ctx.Done():
                                event.Nack()
                                e.logger.Info(fmt.Sprintf(
                                        "event subscriber %s exited with a message nacked when business ctx done", e.name),
                                        watermill.LogFields{watermill.ContextLogFieldKey: ctx})
                                return
                        case <-e.ctx.Done():
                                event.Nack()
                                e.logger.Info(fmt.Sprintf(
                                        "event subscriber %s exited with a message nacked when app ctx done", e.name),
                                        watermill.LogFields{watermill.ContextLogFieldKey: ctx})
                                return
                        }

                        msgs = append(msgs,
                                &message{Message: &mw.Message{Metadata: mw.Metadata{watermill.MessageRouterAck: ""}}})
                        return
                }),
                handleEventSubscriber(),
        )
        return out, err
}

func newAMQP

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/amqp.go:

func newAMQP(ctx context.Context, appName, name string, conf *Conf, logger watermill.LoggerAdapter) (
        pub Publisher, sub Subscriber) {
        if conf.Producer {
                pub = newAMQPPublisher(ctx, appName, name, conf, logger)
        }

        if conf.Consumer {
                sub = newAMQPSubscriber(ctx, appName, name, conf, logger)
        }

        return
}

func newKafka

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/kafka.go:

func newKafka(ctx context.Context, appName, name string, conf *Conf, logger watermill.LoggerAdapter) (
        pub Publisher, sub Subscriber) {
        if conf.Producer {
                pub = newKafkaPublisher(ctx, appName, name, conf, logger)
        }

        if conf.Consumer {
                sub = newKafkaSubscriber(ctx, appName, name, conf, logger)
        }

        return
}

func newPulsar

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/pulsar.go:

func newPulsar(ctx context.Context, appName, name string, conf *Conf, logger watermill.LoggerAdapter) (
        pub Publisher, sub Subscriber) {
        if conf.Producer {
                pub = newPulsarPublisher(ctx, appName, name, conf, logger)
        }

        if conf.Consumer {
                sub = newPulsarSubscriber(ctx, appName, name, conf, logger)
        }

        return
}

func newSub

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mq.go:

func newSub(ctx context.Context, sub mw.Subscriber, appName, name string,
        conf *Conf, logger watermill.LoggerAdapter) *abstractMQ {
        mq := &abstractMQ{ctx: ctx, sub: sub, appName: appName, name: name, conf: clone.Slowly(conf), logger: logger}
        mq.serializeType = serialize.ParseAlgorithm(conf.SerializeType)
        mq.compressType = compress.ParseAlgorithm(conf.CompressType)
        return mq
}

func NewEventPublisher

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

func NewEventPublisher[T eventual](name string, opts ...utils.OptionExtender) EventPublisher[T] {
        opt := utils.ApplyOptions[useOption](opts...)
        publisher := Pub(name, AppName(opt.appName))
        abstractMq := inspect.GetField[*abstractMQ](publisher, "abstractMQ")
        return &eventPublisher[T]{abstractMQ: abstractMq}
}

func newPub

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mq.go:

func newPub(ctx context.Context, pub mw.Publisher, appName, name string,
        conf *Conf, logger watermill.LoggerAdapter) *abstractMQ {
        mq := &abstractMQ{ctx: ctx, pub: pub, appName: appName, name: name, conf: clone.Slowly(conf), logger: logger}
        mq.serializeType = serialize.ParseAlgorithm(conf.SerializeType)
        mq.compressType = compress.ParseAlgorithm(conf.CompressType)
        return mq
}

func messageConvertTo

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mq.go:

280	`func messageConvertTo(src Message) (dst *mw.Message) {`
281	`dst = src.(*message).Message`
282	`return`
283	`}`

func isEventHandler

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

26	`func isEventHandler(f any) bool {`
27	`sig := formatEventHandlerSignature(f)`
28	`return strings.HasPrefix(sig, eventHandlerSignature) \|\| strings.HasPrefix(sig, eventHandlerWithMsgSignature)`
29	`}`

func @182:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/types.go:

182	`func(o *subOption) {`
183	`o.channelLength = channelLength`
184	`}`

func init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/construct.go:

248	`func init() {`
249	`config.AddComponent(config.ComponentMessageQueue, Construct)`
250	`}`

func abstractMQ.watermillSubscriber

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mq.go:

244	`func (a *abstractMQ) watermillSubscriber() mw.Subscriber { return a.sub }`

func mysqlPublisher.close

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mysql.go:

62	`func (m *mysqlPublisher) close() (err error) {`
63	`return m.publisher.Close()`
64	`}`

func EventHandler

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

func EventHandler[T eventual](hdr eventHandler[T]) eventHandler[T] {
        return func(ctx context.Context, event Event[T]) error {
                // TODO: dedup & discard expired event
                return hdr(ctx, event)
        }
}

func @48:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

48	`func(ctx context.Context, event Event[T]) error {`
49	`// TODO: dedup & discard expired event`
50	`return hdr(ctx, event)`
51	`}`

func EventHandlerWithMsg

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

func EventHandlerWithMsg[T eventual](hdr eventHandlerWithMsg[T]) eventHandlerWithMsg[T] {
        return func(ctx context.Context, event Event[T]) ([]Message, error) {
                // TODO: dedup & discard expired event
                return hdr(ctx, event)
        }
}

func @55:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

55	`func(ctx context.Context, event Event[T]) ([]Message, error) {`
56	`// TODO: dedup & discard expired event`
57	`return hdr(ctx, event)`
58	`}`

func @172:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/types.go:

172	`func(o *eventPubOption[T]) {`
173	`o.events = events`
174	`}`

func Events

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/types.go:

func Events[T eventual](events ...Event[T]) utils.OptionFunc[eventPubOption[T]] {
        return func(o *eventPubOption[T]) {
                o.events = events
        }
}

func @42:31

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mysql.go:

42	`func(topic string) string {`
43	`return fmt.Sprintf("%s_%s", conf.MessageScheme, topic)`
44	`}`

func event[T].ID

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

223	`func (e *event[T]) ID() string { return e.pd.I }`

func @161:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/types.go:

161	`func(o *pubOption) {`
162	`o.watermillMessages = messages`
163	`}`

func messages

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/types.go:

func messages(messages ...*mw.Message) utils.OptionFunc[pubOption] {
        return func(o *pubOption) {
                o.watermillMessages = messages
        }
}

func ChannelLen

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/types.go:

func ChannelLen(channelLength int) utils.OptionFunc[subOption] {
        return func(o *subOption) {
                o.channelLength = channelLength
        }
}

func @179:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/construct.go:

179	`func(o *useOption) {`
180	`o.appName = name`
181	`}`

func @158:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/types.go:

158	`func(o *pubOption) { o.messages = messages }`

func Messages

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/types.go:

157	`func Messages(messages ...Message) utils.OptionFunc[pubOption] {`
158	`return func(o *pubOption) { o.messages = messages }`
159	`}`

func UntimedEvent

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

175	`func UntimedEvent[T eventual](id string, payload T) Event[T] {`
176	`return newEvent[T](id, time.Time{}, time.Time{}, time.Time{}, payload)`
177	`}`

func AppName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/construct.go:

func AppName(name string) utils.OptionFunc[useOption] {
        return func(o *useOption) {
                o.appName = name
        }
}

func router.close

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/router.go:

455	`func (r *router) close() (err error) {`
456	`return r.Close()`
457	`}`

func abstractMQ.topic

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mq.go:

242	`func (a *abstractMQ) topic() string { return a.conf.Topic }`

func newEvent

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

func newEvent[T eventual](id string, createdAt, updatedAt, deletedAt time.Time, payload T) Event[T] {
        return &event[T]{
                pd: &eventPayload[T]{
                        I:  id,
                        T:  payload.EventType(),
                        P:  payload,
                        C:  createdAt.Format(time.RFC3339Nano),
                        CL: createdAt.Location().String(),
                        U:  updatedAt.Format(time.RFC3339Nano),
                        UL: updatedAt.Location().String(),
                        D:  deletedAt.Format(time.RFC3339Nano),
                        DL: deletedAt.Location().String(),
                        N:  time.Now().UnixNano(),
                },
        }
}

func @80:31

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mysql.go:

80	`func(topic string) string {`
81	`return fmt.Sprintf("%s_%s", conf.MessageScheme, topic)`
82	`}`

func event[T].Type

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

224	`func (e *event[T]) Type() string { return e.pd.T }`

func event[T].Payload

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

225	`func (e *event[T]) Payload() T { return e.pd.P }`

func @86:38

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mysql.go:

86	`func(topic string) string {`
87	`return fmt.Sprintf("%s_offsets_%s", conf.MessageScheme, topic)`
88	`}`

func handleEventSubscriber

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/types.go:

func handleEventSubscriber() utils.OptionFunc[routerOption] {
        return func(o *routerOption) {
                o.isEventSubscriber = true
        }
}

func router.addEventDispatchHandler

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/router.go:

func (r *router) addEventDispatchHandler(consumerName string) {
        r.Router.AddHandler(
                consumerName,
                r.sub.topic(),
                r.sub.watermillSubscriber(),
                r.pub.topic(),
                r.pub.watermillPublisher(),
                func(msg *mw.Message) (pubMsgs []*mw.Message, err error) {
                        eventType := msg.Metadata[keyEventType]
                        r.locker.RLock()
                        hdr, ok1 := r.eventHandlers[eventType]
                        subhdr, ok2 := r.eventSubscriberHandlers[eventType]
                        r.locker.RUnlock()
                        if !ok1 && !ok2 {
                                rawID := "unknown"
                                if msg.Metadata != nil {
                                        rawID = msg.Metadata[watermill.ContextKeyRawMessageID]
                                }
                                return nil, errors.Errorf(
                                        "handle unknown event message [type[%s] message_uuid[%s] message_raw_id[%s]]",
                                        eventType, msg.UUID, rawID)
                        }
                        handlers := []*handler{hdr, subhdr}

                        wg := new(sync.WaitGroup)
                        futures := make([]*routine.Future, 0, len(handlers))
                        for _, hdr := range handlers {
                                if hdr == nil {
                                        continue
                                }
                                wg.Add(1)
                                f := routine.Promise(
                                        func(hdr handler) (msgs any, err error) {
                                                _, data, _, err := pd.Unseal(msg.Payload,
                                                        pd.Serialize(r.serializeType), pd.Compress(r.compressType), pd.Type(hdr.evtPayloadType))
                                                if err != nil {
                                                        return
                                                }
                                                event := reflect.New(hdr.evtType).Interface()
                                                inspect.SetField(event, "pd", data)

                                                ctx := fusCtx.New(fusCtx.Watermill(msg.Metadata))
                                                ctx = log.SetContextFields(ctx, log.Fields{
                                                        keyEntityID:  msg.Metadata[keyEntityID],
                                                        keyEventType: msg.Metadata[keyEventType],
                                                })
                                                inspect.SetField(event, "ctx", ctx)
                                                inspect.SetField(event, "ackfn", msg.Ack)
                                                inspect.SetField(event, "nackfn", msg.Nack)

                                                rets := hdr.fn.Call([]reflect.Value{reflect.ValueOf(ctx), reflect.ValueOf(event)})
                                                msgs = utils.ParseVariadicFuncResult[[]Message](rets, 0)
                                                err = utils.ParseVariadicFuncResult[error](rets, 0)
                                                return
                                        },
                                        true,
                                        routine.Args(hdr),
                                        routine.WaitGroup(wg),
                                        routine.AppName(r.appName),
                                )
                                futures = append(futures, f)
                        }
                        wg.Wait()

                        pubMsgs = make([]*mw.Message, 0, len(handlers))
                        for _, f := range futures {
                                msgsAny, msgErr := f.Get()
                                err = multierr.Append(err, msgErr)
                                if msgsAny != nil {
                                        msgs, _ := msgsAny.([]Message)
                                        for _, m := range msgs {
                                                pubMsgs = append(pubMsgs, messageConvertTo(m))
                                        }
                                }
                        }
                        return
                },
        )
}

func event[T].Context

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

229	`func (e *event[T]) Context() context.Context { return e.ctx }`

func @192:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/types.go:

192	`func(o *routerOption) {`
193	`o.isEventSubscriber = true`
194	`}`

func rawMessageConvertFrom

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mq.go:

276	`func rawMessageConvertFrom(src *mw.Message) (dst Message) {`
277	`return &message{Message: src, payload: src.Payload}`
278	`}`

func NewMessage

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/types.go:

204	`func NewMessage(uuid string, payload []byte) Message {`
205	`return &message{Message: mw.NewMessage(uuid, payload), payload: payload}`
206	`}`

func _AMQPSubscriber.close

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/amqp.go:

106	`func (a *_AMQPSubscriber) close() (err error) {`
107	`return a.subscriber.Close()`
108	`}`

func goChannel.close

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/gochannel.go:

43	`func (g *goChannel) close() (err error) { return g.ch.Close() }`

func message.ID

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/types.go:

207	`func (m *message) ID() string { return m.Message.UUID }`

func @42:31

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/postgres.go:

42	`func(topic string) string {`
43	`return fmt.Sprintf("%s_%s", conf.MessageScheme, topic)`
44	`}`

func kafkaPublisher.close

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/kafka.go:

54	`func (k *kafkaPublisher) close() (err error) {`
55	`return k.publisher.Close()`
56	`}`

func postgresPublisher.close

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/postgres.go:

62	`func (p *postgresPublisher) close() (err error) {`
63	`return p.publisher.Close()`
64	`}`

func kafkaSubscriber.close

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/kafka.go:

95	`func (k *kafkaSubscriber) close() (err error) {`
96	`return k.subscriber.Close()`
97	`}`

func @80:31

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/postgres.go:

80	`func(topic string) string {`
81	`return fmt.Sprintf("%s_%s", conf.MessageScheme, topic)`
82	`}`

func redisSubscriber.close

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/redis.go:

97	`func (r *redisSubscriber) close() (err error) {`
98	`return r.subscriber.Close()`
99	`}`

func @86:38

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/postgres.go:

86	`func(topic string) string {`
87	`return fmt.Sprintf("%s_offsets_%s", conf.MessageScheme, topic)`
88	`}`

func redisPublisher.close

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/redis.go:

58	`func (r *redisPublisher) close() (err error) {`
59	`return r.publisher.Close()`
60	`}`

func abstractMQ.watermillPublisher

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mq.go:

243	`func (a *abstractMQ) watermillPublisher() mw.Publisher { return a.pub }`

func postgresSubscriber.close

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/postgres.go:

105	`func (p *postgresSubscriber) close() (err error) {`
106	`return p.subscriber.Close()`
107	`}`

func _AMQPPublisher.close

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/amqp.go:

67	`func (a *_AMQPPublisher) close() (err error) {`
68	`return a.publisher.Close()`
69	`}`

func pulsarSubscriber.close

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/pulsar.go:

107	`func (p *pulsarSubscriber) close() (err error) {`
108	`return p.subscriber.Close()`
109	`}`

func message.Payload

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/types.go:

208	`func (m *message) Payload() []byte { return m.payload }`

func router.Running

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/router.go:

197	`func (r *router) Running() <-chan struct{} {`
198	`return r.Router.Running()`
199	`}`

func pulsarPublisher.close

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/pulsar.go:

63	`func (p *pulsarPublisher) close() (err error) {`
64	`return p.publisher.Close()`
65	`}`

func mysqlSubscriber.close

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mysql.go:

105	`func (m *mysqlSubscriber) close() (err error) {`
106	`return m.subscriber.Close()`
107	`}`

func @395:6

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/router.go:

func(hdr handler) (msgs any, err error) {
                                                _, data, _, err := pd.Unseal(msg.Payload,
                                                        pd.Serialize(r.serializeType), pd.Compress(r.compressType), pd.Type(hdr.evtPayloadType))
                                                if err != nil {
                                                        return
                                                }
                                                event := reflect.New(hdr.evtType).Interface()
                                                inspect.SetField(event, "pd", data)

                                                ctx := fusCtx.New(fusCtx.Watermill(msg.Metadata))
                                                ctx = log.SetContextFields(ctx, log.Fields{
                                                        keyEntityID:  msg.Metadata[keyEntityID],
                                                        keyEventType: msg.Metadata[keyEventType],
                                                })
                                                inspect.SetField(event, "ctx", ctx)
                                                inspect.SetField(event, "ackfn", msg.Ack)
                                                inspect.SetField(event, "nackfn", msg.Nack)

                                                rets := hdr.fn.Call([]reflect.Value{reflect.ValueOf(ctx), reflect.ValueOf(event)})
                                                msgs = utils.ParseVariadicFuncResult[[]Message](rets, 0)
                                                err = utils.ParseVariadicFuncResult[error](rets, 0)
                                                return
                                        }

func eventPublisher[T].PublishEvent

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

func (e *eventPublisher[T]) PublishEvent(ctx context.Context, opts ...utils.OptionExtender) (err error) {
        opt := utils.ApplyOptions[pubOption](opts...)
        optT := utils.ApplyOptions[eventPubOption[T]](opts...)
        msgs := make([]*mw.Message, 0, len(optT.events))
        for _, evt := range optT.events {
                msg, err := e.abstractMQ.newObjectMessage(ctx, evt.(*event[T]).pd, opt)
                if msg != nil {
                        msg.Metadata[keyEntityID] = evt.ID()
                        msg.Metadata[keyEventType] = evt.Type()
                }
                if err != nil {
                        return err
                }
                msgs = append(msgs, msg)
        }
        return e.abstractMQ.Publish(ctx, messages(msgs...))
}

func router.handleEvent

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/router.go:

func (r *router) handleEvent(eventType string, fnVal reflect.Value, opt *routerOption) {
        // FIXME: Translating generics to corresponding implemented generic types like this is too hacky.
        //        If this set becomes invalid, switch to the implementation of event payload as any without generics,
        //        and the router can continue to provide it using the current method of storing reflect.Type.
        evtType := fnVal.Type().In(1)
        eventName := strings.Replace(evtType.Name(), "Event[", "event[", 1)
        eventTypeName := fmt.Sprintf(mqPackageSignFormat, eventName)
        et := inspect.TypeOf(eventTypeName)
        if et == nil {
                panic(errors.Errorf("unknown event generic object type: %s", eventTypeName))
        }
        eventPayloadName := strings.Replace(evtType.Name(), "Event[", "eventPayload[", 1)
        eventPayloadTypeName := fmt.Sprintf(mqPackageSignFormat, eventPayloadName)
        ept := inspect.TypeOf(eventPayloadTypeName)
        if ept == nil {
                panic(errors.Errorf("unknown event payload generic object type: %s", eventPayloadTypeName))
        }

        hdr := &handler{
                fn:             fnVal,
                evtType:        et,
                evtPayloadType: reflect.PtrTo(ept),
        }

        r.locker.Lock()
        defer r.locker.Unlock()
        if !opt.isEventSubscriber {
                r.eventHandlers[eventType] = hdr
        } else {
                r.eventSubscriberHandlers[eventType] = hdr
                r.addEventDispatchHandler(defaultRouterEventHandlerName + "_" + eventType)
                routine.Go(r.run, routine.AppName(r.appName))
        }
}

func @41:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/construct.go:

func() {
                locker.Lock()
                defer locker.Unlock()

                pid := syscall.Getpid()
                app := config.Use(opt.AppName).AppName()
                if routers != nil {
                        for name, router := range routers[opt.AppName] {
                                log.Printf("%v [Gofusion] %s %s %s router exiting...",
                                        pid, app, config.ComponentMessageQueue, name)
                                if err := router.close(); err == nil {
                                        log.Printf("%v [Gofusion] %s %s %s router exited",
                                                pid, app, config.ComponentMessageQueue, name)
                                } else {
                                        log.Printf("%v [Gofusion] %s %s %s router exit failed: %s",
                                                pid, app, config.ComponentMessageQueue, name, err)
                                }
                        }
                        delete(routers, opt.AppName)
                }

                if publishers != nil {
                        for name, publisher := range publishers[opt.AppName] {
                                log.Printf("%v [Gofusion] %s %s %s publisher exiting...",
                                        pid, app, config.ComponentMessageQueue, name)
                                if err := publisher.close(); err == nil {
                                        log.Printf("%v [Gofusion] %s %s %s publisher exited",
                                                pid, app, config.ComponentMessageQueue, name)
                                } else {
                                        log.Printf("%v [Gofusion] %s %s %s publisher exit failed: %s",
                                                pid, app, config.ComponentMessageQueue, name, err)
                                }
                        }
                        delete(publishers, opt.AppName)
                }

                if subscribers != nil {
                        for name, subscriber := range subscribers[opt.AppName] {
                                log.Printf("%v [Gofusion] %s %s %s subscriber exiting...",
                                        pid, app, config.ComponentMessageQueue, name)
                                if err := subscriber.close(); err == nil {
                                        log.Printf("%v [Gofusion] %s %s %s subscriber exited",
                                                pid, app, config.ComponentMessageQueue, name)
                                } else {
                                        log.Printf("%v [Gofusion] %s %s %s subscriber exit failed: %s",
                                                pid, app, config.ComponentMessageQueue, name, err)
                                }
                        }
                        delete(subscribers, opt.AppName)
                }
        }

func @370:3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/router.go:

func(msg *mw.Message) (pubMsgs []*mw.Message, err error) {
                        eventType := msg.Metadata[keyEventType]
                        r.locker.RLock()
                        hdr, ok1 := r.eventHandlers[eventType]
                        subhdr, ok2 := r.eventSubscriberHandlers[eventType]
                        r.locker.RUnlock()
                        if !ok1 && !ok2 {
                                rawID := "unknown"
                                if msg.Metadata != nil {
                                        rawID = msg.Metadata[watermill.ContextKeyRawMessageID]
                                }
                                return nil, errors.Errorf(
                                        "handle unknown event message [type[%s] message_uuid[%s] message_raw_id[%s]]",
                                        eventType, msg.UUID, rawID)
                        }
                        handlers := []*handler{hdr, subhdr}

                        wg := new(sync.WaitGroup)
                        futures := make([]*routine.Future, 0, len(handlers))
                        for _, hdr := range handlers {
                                if hdr == nil {
                                        continue
                                }
                                wg.Add(1)
                                f := routine.Promise(
                                        func(hdr handler) (msgs any, err error) {
                                                _, data, _, err := pd.Unseal(msg.Payload,
                                                        pd.Serialize(r.serializeType), pd.Compress(r.compressType), pd.Type(hdr.evtPayloadType))
                                                if err != nil {
                                                        return
                                                }
                                                event := reflect.New(hdr.evtType).Interface()
                                                inspect.SetField(event, "pd", data)

                                                ctx := fusCtx.New(fusCtx.Watermill(msg.Metadata))
                                                ctx = log.SetContextFields(ctx, log.Fields{
                                                        keyEntityID:  msg.Metadata[keyEntityID],
                                                        keyEventType: msg.Metadata[keyEventType],
                                                })
                                                inspect.SetField(event, "ctx", ctx)
                                                inspect.SetField(event, "ackfn", msg.Ack)
                                                inspect.SetField(event, "nackfn", msg.Nack)

                                                rets := hdr.fn.Call([]reflect.Value{reflect.ValueOf(ctx), reflect.ValueOf(event)})
                                                msgs = utils.ParseVariadicFuncResult[[]Message](rets, 0)
                                                err = utils.ParseVariadicFuncResult[error](rets, 0)
                                                return
                                        },
                                        true,
                                        routine.Args(hdr),
                                        routine.WaitGroup(wg),
                                        routine.AppName(r.appName),
                                )
                                futures = append(futures, f)
                        }
                        wg.Wait()

                        pubMsgs = make([]*mw.Message, 0, len(handlers))
                        for _, f := range futures {
                                msgsAny, msgErr := f.Get()
                                err = multierr.Append(err, msgErr)
                                if msgsAny != nil {
                                        msgs, _ := msgsAny.([]Message)
                                        for _, m := range msgs {
                                                pubMsgs = append(pubMsgs, messageConvertTo(m))
                                        }
                                }
                        }
                        return
                }

func formatEventHandlerSignature

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

func formatEventHandlerSignature(f any) string {
        ft, ok := f.(reflect.Type)
        if !ok {
                fv, ok := f.(reflect.Value)
                if ok {
                        ft = fv.Type()
                } else {
                        ft = reflect.TypeOf(f)
                }
        }

        return ft.PkgPath() + "." + ft.Name()
}

func @278:5

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/router.go:

func(wmsg *mw.Message) (msgs []*mw.Message, err error) {
                                        msg, err := messageConvertFrom(wmsg, r.serializeType, r.compressType)
                                        if err != nil {
                                                return
                                        }
                                        rets := fnVal.Convert(handlerFuncType).Call([]reflect.Value{reflect.ValueOf(msg)})
                                        msgs = utils.ParseVariadicFuncResult[[]*mw.Message](rets, 0)
                                        err = utils.ParseVariadicFuncResult[error](rets, 0)
                                        return
                                }

func abstractMQ.SubscribeRaw

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mq.go:

func (a *abstractMQ) SubscribeRaw(ctx context.Context, opts ...utils.OptionExtender) (dst <-chan Message, err error) {
        opt := utils.ApplyOptions[subOption](opts...)
        ch, err := a.sub.Subscribe(ctx, a.conf.Topic)
        if err != nil {
                return
        }

        msgCh := make(chan Message, opt.channelLength)
        routine.Go(func() {
                defer close(msgCh)
                for {
                        select {
                        case wmsg, ok := <-ch:
                                if !ok {
                                        return
                                }
                                msg := rawMessageConvertFrom(wmsg)
                                select {
                                case msgCh <- msg:
                                case <-ctx.Done():
                                        msg.Nack()
                                        a.logger.Info(fmt.Sprintf(
                                                "raw subscriber %s exited with a message nacked when business ctx done", a.name),
                                                watermill.LogFields{watermill.ContextLogFieldKey: ctx})
                                        return
                                case <-a.ctx.Done():
                                        msg.Nack()
                                        a.logger.Info(fmt.Sprintf(
                                                "raw subscriber %s exited with a message nacked when app ctx done", a.name),
                                                watermill.LogFields{watermill.ContextLogFieldKey: ctx})
                                        return
                                }
                        case <-ctx.Done():
                                return
                        case <-a.ctx.Done():
                                return
                        }
                }
        }, routine.AppName(a.appName))
        return msgCh, err
}

func addInstance

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/construct.go:

func addInstance(ctx context.Context, name string, conf *Conf, opt *config.InitOption) {
        var logger watermill.LoggerAdapter
        if utils.IsStrNotBlank(conf.Logger) {
                loggerType := inspect.TypeOf(conf.Logger)
                loggerValue := reflect.New(loggerType)
                if loggerValue.Type().Implements(customLoggerType) {
                        l := fusLog.Use(conf.LogInstance, fusLog.AppName(opt.AppName))
                        loggerValue.Interface().(customLogger).Init(l, opt.AppName, name)
                }
                logger = loggerValue.Convert(watermillLoggerType).Interface().(watermill.LoggerAdapter)
        }

        if conf.ConsumerConcurrency < 1 {
                conf.ConsumerConcurrency = 1
        }

        var (
                puber Publisher
                suber Subscriber
        )
        newFunc, ok := newFn[conf.Type]
        if ok {
                puber, suber = newFunc(ctx, opt.AppName, name, conf, logger)
        } else {
                panic(errors.Errorf("unknown message queue type: %+v", conf.Type))
        }

        locker.Lock()
        defer locker.Unlock()
        if suber != nil {
                if subscribers == nil {
                        subscribers = make(map[string]map[string]Subscriber)
                }
                if subscribers[opt.AppName] == nil {
                        subscribers[opt.AppName] = make(map[string]Subscriber)
                }
                if _, ok := subscribers[name]; ok {
                        panic(ErrDuplicatedSubscriberName)
                }
                subscribers[opt.AppName][name] = suber

                if routers == nil {
                        routers = make(map[string]map[string]IRouter)
                }
                if routers[opt.AppName] == nil {
                        routers[opt.AppName] = make(map[string]IRouter)
                }
                if _, ok := routers[opt.AppName][name]; ok {
                        panic(ErrDuplicatedRouterName)
                }
                routers[opt.AppName][name] = newRouter(ctx, opt.AppName, name, conf, puber, suber, logger)

                // ioc
                if opt.DI != nil {
                        opt.DI.
                                MustProvide(func() Subscriber { return sub(name, AppName(opt.AppName)) }, di.Name(name)).
                                MustProvide(func() IRouter { return Use(name, AppName(opt.AppName)) }, di.Name(name))
                }

        }

        if puber != nil {
                if publishers == nil {
                        publishers = make(map[string]map[string]Publisher)
                }
                if publishers[opt.AppName] == nil {
                        publishers[opt.AppName] = make(map[string]Publisher)
                }
                if _, ok := publishers[opt.AppName][name]; ok {
                        panic(ErrDuplicatedPublisherName)
                }
                publishers[opt.AppName][name] = puber

                // ioc
                if opt.DI != nil {
                        opt.DI.MustProvide(func() Publisher { return Pub(name, AppName(opt.AppName)) }, di.Name(name))
                }
        }
}

func router.isHandlerConflict

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/router.go:

func (r *router) isHandlerConflict() (conflict bool) {
        if len(r.eventHandlers) == 0 {
                return
        }
        for name := range r.Handlers() {
                if !strings.Contains(name, defaultRouterEventHandlerName) {
                        return true
                }
        }
        return
}

func Sub

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/construct.go:

func Sub(name string, opts ...utils.OptionExtender) Subscriber {
        opt := utils.ApplyOptions[useOption](opts...)

        locker.RLock()
        defer locker.RUnlock()
        subscribers, ok := subscribers[opt.appName]
        if !ok {
                panic(errors.Errorf("mq subscriber instance not found for app: %s", opt.appName))
        }
        subscriber, ok := subscribers[name]
        if !ok {
                panic(errors.Errorf("mq subscriber instance not found for name: %s", name))
        }
        return subscriber
}

func Pub

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/construct.go:

func Pub(name string, opts ...utils.OptionExtender) Publisher {
        opt := utils.ApplyOptions[useOption](opts...)

        locker.RLock()
        defer locker.RUnlock()
        publishers, ok := publishers[opt.appName]
        if !ok {
                panic(errors.Errorf("mq publisher instance not found for app: %s", opt.appName))
        }
        publisher, ok := publishers[name]
        if !ok {
                panic(errors.Errorf("mq publisher instance not found for name: %s", name))
        }
        return publisher
}

func Use

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/construct.go:

func Use(name string, opts ...utils.OptionExtender) IRouter {
        opt := utils.ApplyOptions[useOption](opts...)

        locker.RLock()
        defer locker.RUnlock()
        routers, ok := routers[opt.appName]
        if !ok {
                panic(errors.Errorf("mq router instance not found for app: %s", opt.appName))
        }
        r, ok := routers[name]
        if !ok {
                panic(errors.Errorf("mq router instance not found for name: %s", name))
        }
        return r
}

func newRedisPublisher

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/redis.go:

func newRedisPublisher(ctx context.Context, appName, name string, conf *Conf, logger watermill.LoggerAdapter,
        cli rdsDrv.UniversalClient) Publisher {
        cfg := millRds.PublisherConfig{
                Client:                cli,
                Marshaller:            millRds.DefaultMarshallerUnmarshaller{AppID: config.Use(appName).AppName()},
                Maxlens:               nil,
                DisableRedisConnClose: true,
        }

        pub, err := millRds.NewPublisher(cfg, logger)
        if err != nil {
                panic(errors.Wrapf(err, "initialize mq component redis publisher failed: %s", err))
        }

        return &redisPublisher{
                abstractMQ: newPub(ctx, pub, appName, name, conf, logger),
                publisher:  pub,
        }
}

func newMysqlSubscriber

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mysql.go:

func newMysqlSubscriber(ctx context.Context, appName, name string, conf *Conf, logger watermill.LoggerAdapter,
        cli *sql.DB) Subscriber {
        cfg := millSql.SubscriberConfig{
                ConsumerGroup:  conf.ConsumerGroup,
                PollInterval:   0,
                ResendInterval: 0,
                RetryInterval:  0,
                BackoffManager: nil,
                SchemaAdapter: millSql.DefaultMySQLSchema{
                        GenerateMessagesTableName: func(topic string) string {
                                return fmt.Sprintf("%s_%s", conf.MessageScheme, topic)
                        },
                        SubscribeBatchSize: conf.ConsumerConcurrency, // fetch how many rows per query
                },
                OffsetsAdapter: millSql.DefaultMySQLOffsetsAdapter{
                        GenerateMessagesOffsetsTableName: func(topic string) string {
                                return fmt.Sprintf("%s_offsets_%s", conf.MessageScheme, topic)
                        },
                },
                InitializeSchema:  true,
                DisablePersistent: !conf.Persistent,
        }

        sub, err := millSql.NewSubscriber(cli, cfg, logger)
        if err != nil {
                panic(errors.Wrapf(err, "initialize mq component mysql subscriber failed: %s", err))
        }

        return &mysqlSubscriber{
                abstractMQ: newSub(ctx, sub, appName, name, conf, logger),
                subscriber: sub,
        }
}

func newPostgresPublisher

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/postgres.go:

func newPostgresPublisher(ctx context.Context, appName, name string, conf *Conf, logger watermill.LoggerAdapter,
        cli *sql.DB) Publisher {
        cfg := millSql.PublisherConfig{
                SchemaAdapter: millSql.DefaultPostgreSQLSchema{
                        GenerateMessagesTableName: func(topic string) string {
                                return fmt.Sprintf("%s_%s", conf.MessageScheme, topic)
                        },
                        SubscribeBatchSize: conf.ConsumerConcurrency,
                },
                AutoInitializeSchema: true,
                AppID:                config.Use(appName).AppName(),
        }

        pub, err := millSql.NewPublisher(cli, cfg, logger)
        if err != nil {
                panic(errors.Wrapf(err, "initialize mq component postgres publisher failed: %s", err))
        }

        return &postgresPublisher{
                abstractMQ: newPub(ctx, pub, appName, name, conf, logger),
                publisher:  pub,
        }
}

func newKafkaPublisher

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/kafka.go:

func newKafkaPublisher(ctx context.Context, appName, name string,
        conf *Conf, logger watermill.LoggerAdapter) Publisher {
        cfg := kafka.PublisherConfig{
                Brokers:               conf.Endpoint.Addresses,
                Marshaler:             kafka.DefaultMarshaler{AppID: config.Use(appName).AppName()},
                OverwriteSaramaConfig: parseKafkaConf(appName, conf),
        }

        pub, err := kafka.NewPublisher(cfg, logger)
        if err != nil {
                panic(errors.Wrapf(err, "initialize mq component kafka publisher failed: %s", err))
        }

        return &kafkaPublisher{
                abstractMQ: newPub(ctx, pub, appName, name, conf, logger),
                publisher:  pub,
        }
}

func router.Start

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/router.go:

func (r *router) Start() {
        if r.isHandlerConflict() {
                panic(ErrEventHandlerConflict)
        }
        if len(r.eventHandlers) > 0 {
                r.runEventHandlers()
        }
        routine.Go(r.run, routine.AppName(r.appName))
}

func newRedisSubscriber

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/redis.go:

func newRedisSubscriber(ctx context.Context, appName, name string, conf *Conf, logger watermill.LoggerAdapter,
        cli rdsDrv.UniversalClient) Subscriber {
        cfg := millRds.SubscriberConfig{
                Client:                    cli,
                Unmarshaller:              millRds.DefaultMarshallerUnmarshaller{AppID: config.Use(appName).AppName()},
                Consumer:                  "",
                ConsumerGroup:             conf.ConsumerGroup,
                NackResendSleep:           0,
                BlockTime:                 0,
                ClaimInterval:             0,
                ClaimBatchSize:            0,
                MaxIdleTime:               0,
                CheckConsumersInterval:    0,
                ConsumerTimeout:           0,
                OldestId:                  "",
                ShouldClaimPendingMessage: nil,
                DisableRedisConnClose:     true,
        }

        sub, err := millRds.NewSubscriber(cfg, logger)
        if err != nil {
                panic(errors.Wrapf(err, "initialize mq component redis subscriber failed: %s", err))
        }

        return &redisSubscriber{
                abstractMQ: newSub(ctx, sub, appName, name, conf, logger),
                subscriber: sub,
        }
}

func newMysqlPublisher

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mysql.go:

func newMysqlPublisher(ctx context.Context, appName, name string, conf *Conf, logger watermill.LoggerAdapter,
        cli *sql.DB) Publisher {
        cfg := millSql.PublisherConfig{
                SchemaAdapter: millSql.DefaultMySQLSchema{
                        GenerateMessagesTableName: func(topic string) string {
                                return fmt.Sprintf("%s_%s", conf.MessageScheme, topic)
                        },
                        SubscribeBatchSize: 1,
                },
                AutoInitializeSchema: true,
                AppID:                config.Use(appName).AppName(),
        }

        pub, err := millSql.NewPublisher(cli, cfg, logger)
        if err != nil {
                panic(errors.Wrapf(err, "initialize mq component mysql publisher failed: %s", err))
        }

        return &mysqlPublisher{
                abstractMQ: newPub(ctx, pub, appName, name, conf, logger),
                publisher:  pub,
        }
}

func newPostgresSubscriber

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/postgres.go:

func newPostgresSubscriber(ctx context.Context, appName, name string, conf *Conf, logger watermill.LoggerAdapter,
        cli *sql.DB) Subscriber {
        cfg := millSql.SubscriberConfig{
                ConsumerGroup:  conf.ConsumerGroup,
                PollInterval:   0,
                ResendInterval: 0,
                RetryInterval:  0,
                BackoffManager: nil,
                SchemaAdapter: millSql.DefaultPostgreSQLSchema{
                        GenerateMessagesTableName: func(topic string) string {
                                return fmt.Sprintf("%s_%s", conf.MessageScheme, topic)
                        },
                        SubscribeBatchSize: conf.ConsumerConcurrency, // fetch how many rows per query
                },
                OffsetsAdapter: millSql.DefaultPostgreSQLOffsetsAdapter{
                        GenerateMessagesOffsetsTableName: func(topic string) string {
                                return fmt.Sprintf("%s_offsets_%s", conf.MessageScheme, topic)
                        },
                },
                InitializeSchema:  true,
                DisablePersistent: !conf.Persistent,
        }

        sub, err := millSql.NewSubscriber(cli, cfg, logger)
        if err != nil {
                panic(errors.Wrapf(err, "initialize mq component mysql subscriber failed: %s", err))
        }

        return &postgresSubscriber{
                abstractMQ: newSub(ctx, sub, appName, name, conf, logger),
                subscriber: sub,
        }
}

func newAMQPPublisher

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/amqp.go:

func newAMQPPublisher(ctx context.Context, appName, name string, conf *Conf, logger watermill.LoggerAdapter) Publisher {
        ep := parseAMQPEndpoint(conf)

        var genFunc amqp.QueueNameGenerator
        if utils.IsStrNotBlank(conf.ConsumerGroup) {
                genFunc = amqp.GenerateQueueNameTopicNameWithSuffix(conf.ConsumerGroup)
        } else {
                genFunc = amqp.GenerateQueueNameTopicName
        }

        var cfg amqp.Config
        if conf.Persistent {
                cfg = amqp.NewDurablePubSubConfig(ep, genFunc)
        } else {
                cfg = amqp.NewNonDurablePubSubConfig(ep, genFunc)
        }

        cfg.Marshaler = amqp.DefaultMarshaler{
                NotPersistentDeliveryMode: !conf.Persistent,
                AppID:                     config.Use(appName).AppName(),
        }

        pub, err := amqp.NewPublisher(cfg, logger)
        if err != nil {
                panic(errors.Wrapf(err, "initialize mq component amqp publisher failed: %s", err))
        }

        return &_AMQPPublisher{
                abstractMQ: newPub(ctx, pub, appName, name, conf, logger),
                publisher:  pub,
        }
}

func newAMQPSubscriber

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/amqp.go:

func newAMQPSubscriber(ctx context.Context, appName, name string, conf *Conf, logger watermill.LoggerAdapter) Subscriber {
        ep := parseAMQPEndpoint(conf)

        var genFunc amqp.QueueNameGenerator
        if utils.IsStrNotBlank(conf.ConsumerGroup) {
                genFunc = amqp.GenerateQueueNameTopicNameWithSuffix(conf.ConsumerGroup)
        } else {
                genFunc = amqp.GenerateQueueNameTopicName
        }

        var cfg amqp.Config
        if conf.Persistent {
                cfg = amqp.NewDurablePubSubConfig(ep, genFunc)
        } else {
                cfg = amqp.NewNonDurablePubSubConfig(ep, genFunc)
        }

        sub, err := amqp.NewSubscriber(cfg, logger)
        if err != nil {
                panic(errors.Wrapf(err, "initialize mq component amqp subscriber failed: %s", err))
        }

        utils.MustSuccess(sub.SubscribeInitialize(conf.Topic))

        return &_AMQPSubscriber{
                abstractMQ: newSub(ctx, sub, appName, name, conf, logger),
                subscriber: sub,
        }
}

func newRouter

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/router.go:

func newRouter(ctx context.Context, appName, name string, conf *Conf,
        pub Publisher, sub Subscriber, logger watermill.LoggerAdapter) *router {
        r := utils.Must(mw.NewRouter(mw.RouterConfig{CloseTimeout: 15 * time.Second}, logger))
        r.AddPlugin(plugin.SignalsHandler)
        r.AddMiddleware(
                middleware.Recoverer,
                middleware.CorrelationID,
        )
        for _, mwsConf := range conf.ConsumeMiddlewares {
                switch mwsConf.Type {
                case middlewareTypeRetry:
                        r.AddMiddleware(middleware.Retry{
                                MaxRetries:          mwsConf.RetryMaxRetries,
                                InitialInterval:     utils.Must(time.ParseDuration(mwsConf.RetryInitialInterval)),
                                MaxInterval:         utils.Must(time.ParseDuration(mwsConf.RetryMaxInterval)),
                                Multiplier:          mwsConf.RetryMultiplier,
                                MaxElapsedTime:      utils.Must(time.ParseDuration(mwsConf.RetryMaxElapsedTime)),
                                RandomizationFactor: mwsConf.RetryRandomizationFactor,
                                OnRetryHook: func(attempt int, delay time.Duration) {
                                        logTrace(ctx, logger, appName, name,
                                                "retry to consume message [attempt[%v] delay[%s]]", attempt, delay)
                                },
                                Logger: logger,
                        }.Middleware)
                case middlewareTypeThrottle:
                        r.AddMiddleware(
                                middleware.NewThrottle(
                                        int64(mwsConf.ThrottleCount),
                                        utils.Must(time.ParseDuration(mwsConf.ThrottleDuration)),
                                ).Middleware,
                        )
                case middlewareTypeInstanceAck:
                        r.AddMiddleware(middleware.InstantAck)
                case middlewareTypePoison:
                        shouldGoToPoisonQueue := func(err error) bool { return err != nil }
                        r.AddMiddleware(
                                utils.Must(middleware.PoisonQueueWithFilter(
                                        pub.watermillPublisher(),
                                        mwsConf.PoisonTopic,
                                        shouldGoToPoisonQueue,
                                )),
                        )
                case middlewareTypeTimeout:
                        r.AddMiddleware(middleware.Timeout(utils.Must(time.ParseDuration(mwsConf.Timeout))))
                case middlewareTypeCircuitBreaker:
                        var expr gval.Evaluable
                        if utils.IsStrNotBlank(mwsConf.CircuitBreakerTripExpr) {
                                expr = utils.Must(gval.Full().NewEvaluable(mwsConf.CircuitBreakerTripExpr))
                        }
                        r.AddMiddleware(middleware.NewCircuitBreaker(gobreaker.Settings{
                                Name:        name,
                                MaxRequests: uint32(mwsConf.CircuitBreakerMaxRequests),
                                Interval:    utils.Must(time.ParseDuration(mwsConf.CircuitBreakerInterval)),
                                Timeout:     utils.Must(time.ParseDuration(mwsConf.CircuitBreakerTimeout)),
                                ReadyToTrip: func(counts gobreaker.Counts) bool {
                                        // fallback to default ready to trip expression
                                        if expr == nil {
                                                return counts.ConsecutiveFailures > 5
                                        }
                                        if ok, err := expr.EvalBool(ctx, map[string]uint32{
                                                "requests":              counts.Requests,
                                                "total_successes":       counts.TotalSuccesses,
                                                "total_failures":        counts.TotalFailures,
                                                "consecutive_successes": counts.ConsecutiveSuccesses,
                                                "consecutive_failures":  counts.ConsecutiveFailures,
                                        }); err == nil {
                                                return ok
                                        }
                                        // fallback to default ready to trip expression
                                        return counts.ConsecutiveFailures > 5
                                },
                                OnStateChange: func(name string, from gobreaker.State, to gobreaker.State) {
                                        logInfo(ctx, logger, appName, name, "circuit breaker state changed: %s -> %s", from, to)
                                },
                                IsSuccessful: func(err error) bool { return err == nil },
                        }).Middleware)
                default:
                        typ := inspect.TypeOf(string(mwsConf.Type))
                        if typ == nil || typ.ConvertibleTo(watermillHandlerMiddlewareType) {
                                panic(errors.Errorf("unknown mq middleware: %s", mwsConf.Type))
                        }
                        mws := reflect.New(typ).Elem().Convert(watermillHandlerMiddlewareType).Interface()
                        r.AddMiddleware(mws.(mw.HandlerMiddleware))
                }
        }

        rr := &router{
                ctx:                     ctx,
                appName:                 appName,
                c:                       conf,
                pub:                     pub,
                sub:                     sub,
                Router:                  r,
                eventHandlers:           make(map[string]*handler),
                eventSubscriberHandlers: make(map[string]*handler),
        }
        rr.serializeType = serialize.ParseAlgorithm(conf.SerializeType)
        rr.compressType = compress.ParseAlgorithm(conf.CompressType)

        return rr
}

func newPulsarPublisher

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/pulsar.go:

func newPulsarPublisher(ctx context.Context, appName, name string,
        conf *Conf, logger watermill.LoggerAdapter) Publisher {
        cfg := pulsar.PublisherConfig{
                URL:   fmt.Sprintf("pulsar://%s", strings.TrimPrefix(conf.Endpoint.Addresses[0], "pulsar://")),
                AppID: config.Use(appName).AppName(),
        }
        hasUser := utils.IsStrNotBlank(conf.Endpoint.User)
        hasPassword := utils.IsStrNotBlank(conf.Endpoint.Password)
        hasAuthType := utils.IsStrNotBlank(conf.Endpoint.AuthType)
        if hasUser && hasPassword {
                cfg.Authentication = utils.Must(plsDrv.NewAuthenticationBasic(conf.Endpoint.User, conf.Endpoint.Password))
        }
        if hasAuthType {
                cfg.Authentication = utils.Must(plsDrv.NewAuthentication(conf.Endpoint.AuthType, conf.Endpoint.Password))
        }

        pub, err := pulsar.NewPublisher(cfg, logger)
        if err != nil {
                panic(errors.Wrapf(err, "initialize mq component pulsar publisher failed: %s", err))
        }

        return &pulsarPublisher{
                abstractMQ: newPub(ctx, pub, appName, name, conf, logger),
                publisher:  pub,
        }
}

func abstractMQ.PublishRaw

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mq.go:

func (a *abstractMQ) PublishRaw(ctx context.Context, opts ...utils.OptionExtender) (err error) {
        opt := utils.ApplyOptions[pubOption](opts...)
        msgs := opt.watermillMessages
        for _, msg := range opt.messages {
                wmsg := mw.NewMessage(msg.ID(), msg.Payload())
                wmsg.Metadata = fusCtx.WatermillMetadata(ctx)
                wmsg.SetContext(ctx)
                msgs = append(msgs, wmsg)
        }
        if len(msgs) == 0 {
                logInfo(ctx, a.logger, a.appName, a.name, "none messages to publish")
                return
        }

        if !opt.async {
                return a.pub.Publish(ctx, a.conf.Topic, msgs...)
        }

        routine.Goc(ctx, func() {
                idList := utils.SliceMapping(msgs, func(s *mw.Message) (id string) { return s.UUID })
                idList = utils.NewSet(idList...).Items()
                retryFunc := func(attempt uint) error {
                        if attempt > 1 {
                                logInfo(ctx, a.logger, a.appName, a.name,
                                        "retry to publish topic message [topic[%s] message%v[%v] attempt[%v]]",
                                        a.conf.Topic, idList, len(msgs), attempt-1)
                        }
                        return a.pub.Publish(ctx, a.conf.Topic, msgs...)
                }

                if err = retry.Retry(retryFunc, opt.asyncStrategies...); err != nil {
                        logError(ctx, a.logger, a.appName, a.name,
                                "retry to publish topic message failed [err[%s] topic[%s] message%v[%v]]",
                                err, a.conf.Topic, idList, len(msgs))
                }
        }, routine.AppName(a.appName))
        return
}

func newKafkaSubscriber

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/kafka.go:

func newKafkaSubscriber(ctx context.Context, appName, name string,
        conf *Conf, logger watermill.LoggerAdapter) Subscriber {
        cfg := kafka.SubscriberConfig{
                Brokers:               conf.Endpoint.Addresses,
                Unmarshaler:           kafka.DefaultMarshaler{AppID: config.Use(appName).AppName()},
                OverwriteSaramaConfig: parseKafkaConf(appName, conf),
                ConsumerGroup:         conf.ConsumerGroup,
                NackResendSleep:       100 * time.Millisecond,
                ReconnectRetrySleep:   time.Second,
                InitializeTopicDetails: &sarama.TopicDetail{
                        NumPartitions:     -1,
                        ReplicationFactor: -1,
                        ReplicaAssignment: nil,
                        ConfigEntries:     nil,
                },
        }

        sub, err := kafka.NewSubscriber(cfg, logger)
        if err != nil {
                panic(errors.Wrapf(err, "initialize mq component kafka subscriber failed: %s", err))
        }

        if err = sub.SubscribeInitialize(conf.Topic); err != nil {
                panic(errors.Wrapf(err, "initialize mq component kafka subscriber intialize: %s", err))
        }

        return &kafkaSubscriber{
                abstractMQ: newSub(ctx, sub, appName, name, conf, logger),
                subscriber: sub,
        }
}

func abstractMQ.newObjectMessage

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mq.go:

func (a *abstractMQ) newObjectMessage(ctx context.Context, object any, opt *pubOption) (
        msg *mw.Message, err error) {
        payload, err := pd.Seal(object, pd.Compress(a.compressType), pd.Serialize(a.serializeType))
        if err != nil {
                return
        }
        uuid := utils.ULID()
        if opt.objectUUIDGenFunc.IsValid() && opt.objectUUIDGenFunc.Kind() == reflect.Func {
                inType := opt.objectUUIDGenFunc.Type().In(0)
                inParam := reflect.ValueOf(object).Convert(inType)
                uuid = opt.objectUUIDGenFunc.Call([]reflect.Value{inParam})[0].Interface().(string)
        }
        msg = mw.NewMessage(uuid, payload)
        msg.Metadata = fusCtx.WatermillMetadata(ctx)
        msg.SetContext(ctx)
        return
}

func router.run

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/router.go:

func (r *router) run() (err error) {
        if r.Router.IsRunning() {
                return r.Router.RunHandlers(r.ctx)
        }
        if err = r.Router.Run(r.ctx); err != nil {
                if errors.Is(err, mw.ErrRouterIsAlreadyRunning) {
                        return r.Router.RunHandlers(r.ctx)
                }
        }
        return
}

func event[T].Ack

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

func (e *event[T]) Ack() bool {
        if e.ackfn != nil {
                return e.ackfn()
        }
        return true
}

func parseKafkaConf

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/kafka.go:

func parseKafkaConf(appName string, conf *Conf) (saramaCfg *sarama.Config) {
        saramaCfg = sarama.NewConfig()
        saramaCfg.Producer.Return.Errors = true
        saramaCfg.Producer.Return.Successes = true
        saramaCfg.Producer.RequiredAcks = sarama.WaitForLocal
        saramaCfg.Producer.Retry.Max = 10
        saramaCfg.Consumer.Fetch.Default = 16 * 1024 * 1024 // 16mb, default is 1mb
        saramaCfg.Consumer.Offsets.Initial = sarama.OffsetNewest
        saramaCfg.Consumer.Offsets.AutoCommit.Enable = true
        saramaCfg.Consumer.Offsets.AutoCommit.Interval = time.Second // only work when auto commit disabled
        saramaCfg.Consumer.Return.Errors = true
        saramaCfg.Metadata.Retry.Backoff = time.Second * 2
        saramaCfg.ClientID = config.Use(appName).AppName()
        if utils.IsStrNotBlank(conf.Endpoint.Version) {
                saramaCfg.Version = utils.Must(sarama.ParseKafkaVersion(conf.Endpoint.Version))
        }
        if utils.IsStrNotBlank(conf.Endpoint.User) {
                saramaCfg.Net.SASL.Enable = true
                saramaCfg.Net.SASL.User = conf.Endpoint.User
                saramaCfg.Net.SASL.Password = conf.Endpoint.Password
                saramaCfg.Net.SASL.Mechanism = sarama.SASLTypePlaintext
                switch {
                case strings.EqualFold(conf.Endpoint.AuthType, sarama.SASLTypeSCRAMSHA256):
                        saramaCfg.Net.SASL.Mechanism = sarama.SASLTypeSCRAMSHA256
                case strings.EqualFold(conf.Endpoint.AuthType, sarama.SASLTypeSCRAMSHA512):
                        saramaCfg.Net.SASL.Mechanism = sarama.SASLTypeSCRAMSHA512
                case strings.EqualFold(conf.Endpoint.AuthType, sarama.SASLTypeOAuth):
                        saramaCfg.Net.SASL.Mechanism = sarama.SASLTypeOAuth
                        saramaCfg.Net.SASL.TokenProvider = &kafkaOAuthProvider{token: saramaCfg.Net.SASL.Password}
                }
        }
        return
}

func messageConvertFrom

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mq.go:

func messageConvertFrom(src *mw.Message,
        serializeType serialize.Algorithm, compressType compress.Algorithm) (dst Message, err error) {
        _, data, isRaw, err := pd.UnsealRaw(src.Payload, pd.Compress(compressType))
        if err != nil {
                return
        }
        src.SetContext(fusCtx.New(fusCtx.Watermill(src.Metadata)))
        msg := &message{Message: src, payload: data}
        if !isRaw {
                _, msg.obj, _, err = pd.Unseal(src.Payload,
                        pd.Serialize(serializeType), pd.Compress(compressType))
                if err != nil {
                        return
                }
        }
        dst = msg
        return
}

func newPulsarSubscriber

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/pulsar.go:

func newPulsarSubscriber(ctx context.Context, appName, name string,
        conf *Conf, logger watermill.LoggerAdapter) Subscriber {
        cfg := &pulsar.SubscriberConfig{
                URL:        fmt.Sprintf("pulsar://%s", strings.TrimPrefix(conf.Endpoint.Addresses[0], "pulsar://")),
                QueueGroup: conf.ConsumerGroup,
                Persistent: conf.Persistent,
        }
        hasUser := utils.IsStrNotBlank(conf.Endpoint.User)
        hasPassword := utils.IsStrNotBlank(conf.Endpoint.Password)
        hasAuthType := utils.IsStrNotBlank(conf.Endpoint.AuthType)
        if hasUser && hasPassword {
                cfg.Authentication = utils.Must(plsDrv.NewAuthenticationBasic(conf.Endpoint.User, conf.Endpoint.Password))
        }
        if hasAuthType {
                params := conf.Endpoint.Password
                switch conf.Endpoint.AuthType {
                case "basic", "org.apache.pulsar.client.impl.auth.AuthenticationBasic":
                        params = utils.MustJsonMarshalString(map[string]string{
                                "username": conf.Endpoint.User,
                                "password": conf.Endpoint.Password,
                        })
                }
                cfg.Authentication = utils.Must(plsDrv.NewAuthentication(conf.Endpoint.AuthType, params))
        }

        sub, err := pulsar.NewSubscriber(cfg, logger)
        if err != nil {
                panic(errors.Wrapf(err, "initialize mq component pulsar subscriber failed: %s", err))
        }

        return &pulsarSubscriber{
                abstractMQ: newSub(ctx, sub, appName, name, conf, logger),
                subscriber: sub,
        }
}

func parseAMQPEndpoint

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/amqp.go:

func parseAMQPEndpoint(conf *Conf) (result string) {
        hasUser := utils.IsStrNotBlank(conf.Endpoint.User)
        hasPassword := utils.IsStrNotBlank(conf.Endpoint.Password)
        if hasUser && hasPassword {
                addr := strings.TrimPrefix(conf.Endpoint.Addresses[0], "amqp://")
                result = fmt.Sprintf("amqp://%s:%s@%s", conf.Endpoint.User, conf.Endpoint.Password, addr)
        } else if hasUser {
                addr := strings.TrimPrefix(conf.Endpoint.Addresses[0], "amqp://")
                result = fmt.Sprintf("amqp://%s@%s", conf.Endpoint.User, addr)
        } else {
                addr := strings.TrimPrefix(conf.Endpoint.Addresses[0], "amqp://")
                result = fmt.Sprintf("amqp://%s", addr)
        }

        return
}

func @146:13

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mq.go:

func() {
                defer close(msgCh)
                for {
                        select {
                        case wmsg, ok := <-ch:
                                if !ok {
                                        return
                                }
                                msg := rawMessageConvertFrom(wmsg)
                                select {
                                case msgCh <- msg:
                                case <-ctx.Done():
                                        msg.Nack()
                                        a.logger.Info(fmt.Sprintf(
                                                "raw subscriber %s exited with a message nacked when business ctx done", a.name),
                                                watermill.LogFields{watermill.ContextLogFieldKey: ctx})
                                        return
                                case <-a.ctx.Done():
                                        msg.Nack()
                                        a.logger.Info(fmt.Sprintf(
                                                "raw subscriber %s exited with a message nacked when app ctx done", a.name),
                                                watermill.LogFields{watermill.ContextLogFieldKey: ctx})
                                        return
                                }
                        case <-ctx.Done():
                                return
                        case <-a.ctx.Done():
                                return
                        }
                }
        }

func router.addHandler

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/router.go:

func (r *router) addHandler(handlerName, consumerName string, hdr any, opt *routerOption) {
        switch fn := hdr.(type) {
        case HandlerFunc:
                r.Router.AddNoPublisherHandler(
                        consumerName,
                        r.sub.topic(),
                        r.sub.watermillSubscriber(),
                        func(wmsg *mw.Message) (err error) {
                                msg, err := messageConvertFrom(wmsg, r.serializeType, r.compressType)
                                if err != nil {
                                        return
                                }
                                return fn(msg)
                        },
                )
        case mw.NoPublishHandlerFunc:
                r.Router.AddNoPublisherHandler(
                        consumerName,
                        r.sub.topic(),
                        r.sub.watermillSubscriber(),
                        fn,
                )
        case mw.HandlerFunc:
                r.Router.AddHandler(
                        consumerName,
                        r.sub.topic(),
                        r.sub.watermillSubscriber(),
                        r.pub.topic(),
                        r.pub.watermillPublisher(),
                        fn,
                )
        default:
                fnVal := reflect.ValueOf(hdr)
                switch {
                case fnVal.CanConvert(watermillHandlerFuncType):
                        r.Router.AddNoPublisherHandler(
                                consumerName,
                                r.sub.topic(),
                                r.sub.watermillSubscriber(),
                                func(msg *mw.Message) error {
                                        rets := fnVal.Convert(watermillHandlerFuncType).Call(
                                                []reflect.Value{reflect.ValueOf(rawMessageConvertFrom(msg))},
                                        )
                                        return utils.ParseVariadicFuncResult[error](rets, 0)
                                },
                        )
                case fnVal.CanConvert(watermillNoPublishHandlerFuncType):
                        r.Router.AddNoPublisherHandler(
                                consumerName,
                                r.sub.topic(),
                                r.sub.watermillSubscriber(),
                                func(msg *mw.Message) error {
                                        rets := fnVal.
                                                Convert(watermillNoPublishHandlerFuncType).
                                                Call([]reflect.Value{reflect.ValueOf(msg)})
                                        return utils.ParseVariadicFuncResult[error](rets, 0)
                                },
                        )
                case fnVal.CanConvert(handlerFuncType):
                        r.Router.AddHandler(
                                consumerName,
                                r.sub.topic(),
                                r.sub.watermillSubscriber(),
                                r.pub.topic(),
                                r.pub.watermillPublisher(),
                                func(wmsg *mw.Message) (msgs []*mw.Message, err error) {
                                        msg, err := messageConvertFrom(wmsg, r.serializeType, r.compressType)
                                        if err != nil {
                                                return
                                        }
                                        rets := fnVal.Convert(handlerFuncType).Call([]reflect.Value{reflect.ValueOf(msg)})
                                        msgs = utils.ParseVariadicFuncResult[[]*mw.Message](rets, 0)
                                        err = utils.ParseVariadicFuncResult[error](rets, 0)
                                        return
                                },
                        )
                case isEventHandler(fnVal):
                        r.handleEvent(handlerName, fnVal, opt)
                default:
                        r.Router.AddNoPublisherHandler(
                                consumerName,
                                r.sub.topic(),
                                r.sub.watermillSubscriber(),
                                r.handle(hdr),
                        )
                }
        }
}

func abstractMQ.Publish

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mq.go:

func (a *abstractMQ) Publish(ctx context.Context, opts ...utils.OptionExtender) (err error) {
        opt := utils.ApplyOptions[pubOption](opts...)
        msgs := opt.watermillMessages
        for _, msg := range opt.messages {
                msg, err := a.newMessage(ctx, msg, opt)
                if err != nil {
                        return err
                }
                msgs = append(msgs, msg)
        }
        for _, object := range opt.objects {
                msg, err := a.newObjectMessage(ctx, object, opt)
                if err != nil {
                        return err
                }
                msgs = append(msgs, msg)
        }
        if len(msgs) == 0 {
                logInfo(ctx, a.logger, a.appName, a.name, "none messages to publish")
                return
        }

        if !opt.async {
                return a.pub.Publish(ctx, a.conf.Topic, msgs...)
        }

        routine.Goc(ctx, func() {
                idList := utils.SliceMapping(msgs, func(s *mw.Message) (id string) { return s.UUID })
                idList = utils.NewSet(idList...).Items()
                retryFunc := func(attempt uint) error {
                        if attempt > 1 {
                                logInfo(ctx, a.logger, a.appName, a.name,
                                        "retry to publish topic message [topic[%s] message%v[%v] attempt[%v]]",
                                        a.conf.Topic, idList, len(msgs), attempt-1)
                        }
                        return a.pub.Publish(ctx, a.conf.Topic, msgs...)
                }

                if err = retry.Retry(retryFunc, opt.asyncStrategies...); err != nil {
                        logError(ctx, a.logger, a.appName, a.name,
                                "retry to publish topic message failed [err[%s] topic[%s] message%v[%v]]",
                                err, a.conf.Topic, idList, len(msgs))
                }
        }, routine.AppName(a.appName))
        return
}

func @129:26

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

func(ctx context.Context, event Event[T]) (msgs []Message, err error) {
                        select {
                        case out <- event:
                        case <-r.Router.ClosingInProgressCh:
                                event.Nack()
                                e.logger.Info(fmt.Sprintf("event subscriber %s exited", e.name), nil)
                                return
                        case <-ctx.Done():
                                event.Nack()
                                e.logger.Info(fmt.Sprintf(
                                        "event subscriber %s exited with a message nacked when business ctx done", e.name),
                                        watermill.LogFields{watermill.ContextLogFieldKey: ctx})
                                return
                        case <-e.ctx.Done():
                                event.Nack()
                                e.logger.Info(fmt.Sprintf(
                                        "event subscriber %s exited with a message nacked when app ctx done", e.name),
                                        watermill.LogFields{watermill.ContextLogFieldKey: ctx})
                                return
                        }

                        msgs = append(msgs,
                                &message{Message: &mw.Message{Metadata: mw.Metadata{watermill.MessageRouterAck: ""}}})
                        return
                }

func @188:13

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mq.go:

func() {
                defer close(msgCh)
                for {
                        select {
                        case wmsg, ok := <-ch:
                                if !ok {
                                        return
                                }
                                _, data, isRaw, err := pd.UnsealRaw(wmsg.Payload, pd.Compress(a.compressType))
                                if err != nil {
                                        a.logger.Error("unseal message failed", err, watermill.LogFields{
                                                watermill.ContextLogFieldKey: ctx,
                                        })
                                        continue
                                }
                                wmsg.SetContext(fusCtx.New(fusCtx.Watermill(wmsg.Metadata)))
                                msg := &message{Message: wmsg, payload: data}
                                if !isRaw {
                                        _, msg.obj, _, err = pd.Unseal(wmsg.Payload,
                                                pd.Serialize(a.serializeType), pd.Compress(a.compressType))
                                        if err != nil {
                                                a.logger.Error("unseal message object failed", err, watermill.LogFields{
                                                        watermill.ContextLogFieldKey: ctx,
                                                })
                                                continue
                                        }
                                }
                                select {
                                case msgCh <- msg:
                                case <-ctx.Done():
                                        msg.Nack()
                                        a.logger.Info(fmt.Sprintf(
                                                "subscriber %s exited with a message nacked when business ctx done", a.name),
                                                watermill.LogFields{watermill.ContextLogFieldKey: ctx})
                                        return
                                case <-a.ctx.Done():
                                        msg.Nack()
                                        a.logger.Info(fmt.Sprintf(
                                                "subscriber %s exited with a message nacked when app ctx done", a.name),
                                                watermill.LogFields{watermill.ContextLogFieldKey: ctx})
                                        return
                                }

                        case <-ctx.Done():
                                return
                        case <-a.ctx.Done():
                                return
                        }
                }
        }

func setParams

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/utils.go:

func setParams(typ reflect.Type, embed bool, params ...any) (arg any) {
        if typ == nil {
                return
        }

        argValPtr := reflect.New(typ)
        argVal := argValPtr.Elem()
        if !embed {
                if len(params) > 0 {
                        argVal.Set(reflect.ValueOf(params[0]))
                }
                return argValPtr.Interface()
        }

        for i := 0; i < len(params); i++ {
                ft := argVal.Field(i)
                ft.Set(reflect.ValueOf(params[i]).Convert(ft.Type()))
        }
        return argValPtr.Interface()
}

func formatFields

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/log.go:

func formatFields(ctx context.Context) (fs watermill.LogFields) {
        fs = make(watermill.LogFields, 4)
        if userID := fusCtx.GetUserID(ctx); utils.IsStrNotBlank(userID) {
                fs["user_id"] = userID
        }
        if traceID := fusCtx.GetTraceID(ctx); utils.IsStrNotBlank(traceID) {
                fs["trace_id"] = traceID
        }
        if taskID := fusCtx.GetCronTaskID(ctx); utils.IsStrNotBlank(taskID) {
                fs["cron_task_id"] = taskID
        }
        if taskName := fusCtx.GetCronTaskName(ctx); utils.IsStrNotBlank(taskName) {
                fs["cron_task_name"] = taskName
        }
        return
}

func sub

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/construct.go:

func sub(name string, opts ...utils.OptionExtender) Subscriber {
        opt := utils.ApplyOptions[useOption](opts...)

        locker.RLock()
        defer locker.RUnlock()
        subscribers, ok := subscribers[opt.appName]
        if !ok {
                panic(errors.Errorf("mq subscriber instance not found for app: %s", opt.appName))
        }
        subscriber, ok := subscribers[name]
        if !ok {
                panic(errors.Errorf("mq subscriber instance not found for name: %s", name))
        }
        return subscriber
}

func router.Serve

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/router.go:

func (r *router) Serve() (err error) {
        if r.isHandlerConflict() {
                panic(ErrEventHandlerConflict)
        }
        if len(r.eventHandlers) > 0 {
                r.runEventHandlers()
        }
        if err = r.run(); err != nil {
                return
        }
        <-r.Router.ClosedCh
        return
}

func wrapParams

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/utils.go:

func wrapParams(fn any) (argType reflect.Type) {
        typ := reflect.TypeOf(fn)

        inLength := typ.NumIn()
        if inLength == 1 {
                return
        }
        if inLength >= 2 {
                return typ.In(1)
        }

        return
}

func abstractMQ.newMessage

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mq.go:

func (a *abstractMQ) newMessage(ctx context.Context, src Message, _ *pubOption) (
        msg *mw.Message, err error) {
        payload, err := pd.Seal(src.Payload(), pd.Compress(a.compressType))
        if err != nil {
                return
        }
        msg = mw.NewMessage(src.ID(), payload)
        msg.Metadata = fusCtx.WatermillMetadata(ctx)
        msg.SetContext(ctx)
        return
}

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mq.go:

func (a *abstractMQ) Subscribe(ctx context.Context, opts ...utils.OptionExtender) (dst <-chan Message, err error) {
        opt := utils.ApplyOptions[subOption](opts...)
        ch, err := a.sub.Subscribe(ctx, a.conf.Topic)
        if err != nil {
                return
        }

        msgCh := make(chan Message, opt.channelLength)
        routine.Go(func() {
                defer close(msgCh)
                for {
                        select {
                        case wmsg, ok := <-ch:
                                if !ok {
                                        return
                                }
                                _, data, isRaw, err := pd.UnsealRaw(wmsg.Payload, pd.Compress(a.compressType))
                                if err != nil {
                                        a.logger.Error("unseal message failed", err, watermill.LogFields{
                                                watermill.ContextLogFieldKey: ctx,
                                        })
                                        continue
                                }
                                wmsg.SetContext(fusCtx.New(fusCtx.Watermill(wmsg.Metadata)))
                                msg := &message{Message: wmsg, payload: data}
                                if !isRaw {
                                        _, msg.obj, _, err = pd.Unseal(wmsg.Payload,
                                                pd.Serialize(a.serializeType), pd.Compress(a.compressType))
                                        if err != nil {
                                                a.logger.Error("unseal message object failed", err, watermill.LogFields{
                                                        watermill.ContextLogFieldKey: ctx,
                                                })
                                                continue
                                        }
                                }
                                select {
                                case msgCh <- msg:
                                case <-ctx.Done():
                                        msg.Nack()
                                        a.logger.Info(fmt.Sprintf(
                                                "subscriber %s exited with a message nacked when business ctx done", a.name),
                                                watermill.LogFields{watermill.ContextLogFieldKey: ctx})
                                        return
                                case <-a.ctx.Done():
                                        msg.Nack()
                                        a.logger.Info(fmt.Sprintf(
                                                "subscriber %s exited with a message nacked when app ctx done", a.name),
                                                watermill.LogFields{watermill.ContextLogFieldKey: ctx})
                                        return
                                }

                        case <-ctx.Done():
                                return
                        case <-a.ctx.Done():
                                return
                        }
                }
        }, routine.AppName(a.appName))
        return msgCh, err
}

func @340:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/router.go:

func(msg *mw.Message) (err error) {
                _, data, _, err := pd.Unseal(msg.Payload,
                        pd.Serialize(r.serializeType), pd.Compress(r.compressType), pd.Type(typ))
                if err != nil {
                        return
                }
                params := unwrapParams(typ, data)
                ctx := fusCtx.New(fusCtx.Watermill(msg.Metadata))
                return fn(append([]any{ctx}, params...)...)
        }

func @117:19

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mq.go:

func() {
                idList := utils.SliceMapping(msgs, func(s *mw.Message) (id string) { return s.UUID })
                idList = utils.NewSet(idList...).Items()
                retryFunc := func(attempt uint) error {
                        if attempt > 1 {
                                logInfo(ctx, a.logger, a.appName, a.name,
                                        "retry to publish topic message [topic[%s] message%v[%v] attempt[%v]]",
                                        a.conf.Topic, idList, len(msgs), attempt-1)
                        }
                        return a.pub.Publish(ctx, a.conf.Topic, msgs...)
                }

                if err = retry.Retry(retryFunc, opt.asyncStrategies...); err != nil {
                        logError(ctx, a.logger, a.appName, a.name,
                                "retry to publish topic message failed [err[%s] topic[%s] message%v[%v]]",
                                err, a.conf.Topic, idList, len(msgs))
                }
        }

func @78:19

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mq.go:

func() {
                idList := utils.SliceMapping(msgs, func(s *mw.Message) (id string) { return s.UUID })
                idList = utils.NewSet(idList...).Items()
                retryFunc := func(attempt uint) error {
                        if attempt > 1 {
                                logInfo(ctx, a.logger, a.appName, a.name,
                                        "retry to publish topic message [topic[%s] message%v[%v] attempt[%v]]",
                                        a.conf.Topic, idList, len(msgs), attempt-1)
                        }
                        return a.pub.Publish(ctx, a.conf.Topic, msgs...)
                }

                if err = retry.Retry(retryFunc, opt.asyncStrategies...); err != nil {
                        logError(ctx, a.logger, a.appName, a.name,
                                "retry to publish topic message failed [err[%s] topic[%s] message%v[%v]]",
                                err, a.conf.Topic, idList, len(msgs))
                }
        }

func @113:18

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/router.go:

func(counts gobreaker.Counts) bool {
                                        // fallback to default ready to trip expression
                                        if expr == nil {
                                                return counts.ConsecutiveFailures > 5
                                        }
                                        if ok, err := expr.EvalBool(ctx, map[string]uint32{
                                                "requests":              counts.Requests,
                                                "total_successes":       counts.TotalSuccesses,
                                                "total_failures":        counts.TotalFailures,
                                                "consecutive_successes": counts.ConsecutiveSuccesses,
                                                "consecutive_failures":  counts.ConsecutiveFailures,
                                        }); err == nil {
                                                return ok
                                        }
                                        // fallback to default ready to trip expression
                                        return counts.ConsecutiveFailures > 5
                                }

func event[T].toTime

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

func (e *event[T]) toTime(timestr, locationstr string) (t time.Time) {
        loc, err := time.LoadLocation(locationstr)
        if err != nil {
                loc = constant.DefaultLocation()
        }
        t, _ = time.ParseInLocation(time.RFC3339Nano, timestr, loc)
        return
}

func @220:4

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/router.go:

func(wmsg *mw.Message) (err error) {
                                msg, err := messageConvertFrom(wmsg, r.serializeType, r.compressType)
                                if err != nil {
                                        return
                                }
                                return fn(msg)
                        }

func event[T].Nack

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

func (e *event[T]) Nack() bool {
        if e.nackfn != nil {
                return e.nackfn()
        }
        return true
}

func @120:16

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mq.go:

func(attempt uint) error {
                        if attempt > 1 {
                                logInfo(ctx, a.logger, a.appName, a.name,
                                        "retry to publish topic message [topic[%s] message%v[%v] attempt[%v]]",
                                        a.conf.Topic, idList, len(msgs), attempt-1)
                        }
                        return a.pub.Publish(ctx, a.conf.Topic, msgs...)
                }

func @150:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/types.go:

func(o *pubOption) {
                o.objects = objects
                if objectUUIDGenFunc != nil {
                        o.objectUUIDGenFunc = reflect.ValueOf(objectUUIDGenFunc)
                }
        }

func @81:16

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mq.go:

func(attempt uint) error {
                        if attempt > 1 {
                                logInfo(ctx, a.logger, a.appName, a.name,
                                        "retry to publish topic message [topic[%s] message%v[%v] attempt[%v]]",
                                        a.conf.Topic, idList, len(msgs), attempt-1)
                        }
                        return a.pub.Publish(ctx, a.conf.Topic, msgs...)
                }

func router.handle

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/router.go:

func (r *router) handle(hdr any) mw.NoPublishHandlerFunc {
        typ := wrapParams(hdr)
        fn := utils.WrapFunc1[error](hdr)
        return func(msg *mw.Message) (err error) {
                _, data, _, err := pd.Unseal(msg.Payload,
                        pd.Serialize(r.serializeType), pd.Compress(r.compressType), pd.Type(typ))
                if err != nil {
                        return
                }
                params := unwrapParams(typ, data)
                ctx := fusCtx.New(fusCtx.Watermill(msg.Metadata))
                return fn(append([]any{ctx}, params...)...)
        }
}

func unwrapParams

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/utils.go:

func unwrapParams(typ reflect.Type, arg any) (params []any) {
        if typ == nil {
                return
        }

        return []any{arg}
}

func @166:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/types.go:

166	`func(o *pubOption) {`
167	`o.async = true`
168	`o.asyncStrategies = strategies`
169	`}`

func @252:5

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/router.go:

func(msg *mw.Message) error {
                                        rets := fnVal.Convert(watermillHandlerFuncType).Call(
                                                []reflect.Value{reflect.ValueOf(rawMessageConvertFrom(msg))},
                                        )
                                        return utils.ParseVariadicFuncResult[error](rets, 0)
                                }

func @264:5

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/router.go:

func(msg *mw.Message) error {
                                        rets := fnVal.
                                                Convert(watermillNoPublishHandlerFuncType).
                                                Call([]reflect.Value{reflect.ValueOf(msg)})
                                        return utils.ParseVariadicFuncResult[error](rets, 0)
                                }

func formatLogMsg

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/log.go:

func formatLogMsg(app, n, src string, args ...any) (dst string) {
        appName := config.Use(app).AppName()
        return fmt.Sprintf("%v [Gofusion] %s %s %s %s",
                syscall.Getpid(), appName, config.ComponentMessageQueue, n, fmt.Sprintf(src, args...))
}

func event[T].DeletedAt

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

228	`func (e *event[T]) DeletedAt() time.Time { return e.toTime(e.pd.D, e.pd.DL) }`

func logDebug

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/log.go:

21	`func logDebug(ctx context.Context, l watermill.LoggerAdapter, app, n, m string, args ...any) {`
22	`l.Debug(formatLogMsg(app, n, m, args...), formatFields(ctx))`
23	`}`

func @79:38

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mq.go:

79	`func(s *mw.Message) (id string) { return s.UUID }`

func @118:38

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mq.go:

118	`func(s *mw.Message) (id string) { return s.UUID }`

func @133:19

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/router.go:

133	`func(err error) bool { return err == nil }`

func event[T].UpdatedAt

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

227	`func (e *event[T]) UpdatedAt() time.Time { return e.toTime(e.pd.U, e.pd.UL) }`

func event[T].CreatedAt

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

226	`func (e *event[T]) CreatedAt() time.Time { return e.toTime(e.pd.C, e.pd.CL) }`

func EventDeleted

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

184	`func EventDeleted[T eventual](id string, deletedAt time.Time, payload T) Event[T] {`
185	`return newEvent[T](id, time.Time{}, time.Time{}, deletedAt, payload)`
186	`}`

func EventUpdated

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

181	`func EventUpdated[T eventual](id string, updatedAt time.Time, payload T) Event[T] {`
182	`return newEvent[T](id, time.Time{}, updatedAt, time.Time{}, payload)`
183	`}`

func Objects

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/types.go:

func Objects[T any](objectUUIDGenFunc func(T) string, objects ...any) utils.OptionFunc[pubOption] {
        return func(o *pubOption) {
                o.objects = objects
                if objectUUIDGenFunc != nil {
                        o.objectUUIDGenFunc = reflect.ValueOf(objectUUIDGenFunc)
                }
        }
}

func EventCreated

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

178	`func EventCreated[T eventual](id string, createdAt time.Time, payload T) Event[T] {`
179	`return newEvent[T](id, createdAt, time.Time{}, time.Time{}, payload)`
180	`}`

func NewEvent

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

172	`func NewEvent[T eventual](id string, createdAt, updatedAt, deletedAt time.Time, payload T) Event[T] {`
173	`return newEvent[T](id, createdAt, updatedAt, deletedAt, payload)`
174	`}`

func @150:17

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/construct.go:

150	`func() IRouter { return Use(name, AppName(opt.AppName)) }`

func @102:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

102	`func() EventSubscriber[T] {`
103	`return NewEventSubscriber[T](name, opts...)`
104	`}`

func NewEventSubscriberDI

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

func NewEventSubscriberDI[T eventual](name string, opts ...utils.OptionExtender) func() EventSubscriber[T] {
        return func() EventSubscriber[T] {
                return NewEventSubscriber[T](name, opts...)
        }
}

func Async

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/types.go:

func Async(strategies ...strategy.Strategy) utils.OptionFunc[pubOption] {
        return func(o *pubOption) {
                o.async = true
                o.asyncStrategies = strategies
        }
}

func @130:20

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/router.go:

130	`func(name string, from gobreaker.State, to gobreaker.State) {`
131	`logInfo(ctx, logger, appName, name, "circuit breaker state changed: %s -> %s", from, to)`
132	`}`

func @62:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

62	`func() EventPublisher[T] {`
63	`return NewEventPublisher[T](name, opts...)`
64	`}`

func NewEventPublisherDI

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/event.go:

func NewEventPublisherDI[T eventual](name string, opts ...utils.OptionExtender) func() EventPublisher[T] {
        return func() EventPublisher[T] {
                return NewEventPublisher[T](name, opts...)
        }
}

func @77:18

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/router.go:

77	`func(attempt int, delay time.Duration) {`
78	`logTrace(ctx, logger, appName, name,`
79	`"retry to consume message [attempt[%v] delay[%s]]", attempt, delay)`
80	`}`

func @169:23

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/construct.go:

169	`func() Publisher { return Pub(name, AppName(opt.AppName)) }`

func kafkaOAuthProvider.Token

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/kafka.go:

137	`func (k kafkaOAuthProvider) Token() (sarama.AccessToken, error) {`
138	`return &sarama.AccessToken{Token: k.token}, nil`
139	`}`

func @149:17

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/construct.go:

149	`func() Subscriber { return sub(name, AppName(opt.AppName)) }`

func abstractMQ.close

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mq.go:

241	`func (a *abstractMQ) close() error { panic(ErrNotImplement) }`

func abstractMQ.watermillLogger

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/mq.go:

245	`func (a *abstractMQ) watermillLogger() watermill.LoggerAdapter { return a.logger }`

func logError

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/log.go:

15	`func logError(ctx context.Context, l watermill.LoggerAdapter, app, n, m string, args ...any) {`
16	`l.Error(formatLogMsg(app, n, m, args...), nil, formatFields(ctx))`
17	`}`

func message.RawMessage

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/types.go:

209	`func (m *message) RawMessage() any { return m.Message }`

func message.Object

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/types.go:

210	`func (m *message) Object() any { return m.obj }`

func logInfo

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/log.go:

18	`func logInfo(ctx context.Context, l watermill.LoggerAdapter, app, n, m string, args ...any) {`
19	`l.Info(formatLogMsg(app, n, m, args...), formatFields(ctx))`
20	`}`

func logTrace

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/log.go:

24	`func logTrace(ctx context.Context, l watermill.LoggerAdapter, app, n, m string, args ...any) {`
25	`l.Trace(formatLogMsg(app, n, m, args...), formatFields(ctx))`
26	`}`

func @93:29

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/mq/router.go:

93	`func(err error) bool { return err != nil }`

Package Overview: github.com/wfusion/gofusion/redis 23.4%

Please select a function to see what's left for testing.

`startDaemonRoutines(...)`	`github.com/wfusion/gofusion/redis/metrics.go`	`100.0%`	`10/10`
`Construct(...)`	`github.com/wfusion/gofusion/redis/construct.go`	`100.0%`	`7/7`
`instance.XAdd(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`100.0%`	`1/1`
`instance.Subscribe(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`100.0%`	`1/1`
`init(...)`	`github.com/wfusion/gofusion/redis/construct.go`	`100.0%`	`1/1`
`instance.MGet(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`100.0%`	`1/1`
`instance.Set(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`100.0%`	`1/1`
`instance.SetNX(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`100.0%`	`1/1`
`instance.Del(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`100.0%`	`1/1`
`instance.XAck(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`100.0%`	`1/1`
`instance.GetProxy(...)`	`github.com/wfusion/gofusion/redis/redis.go`	`100.0%`	`1/1`
`AppName(...)`	`github.com/wfusion/gofusion/redis/redis.go`	`100.0%`	`1/1`
`@39:9(...)`	`github.com/wfusion/gofusion/redis/redis.go`	`100.0%`	`1/1`
`instance.SAdd(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`100.0%`	`1/1`
`instance.Pipeline(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`100.0%`	`1/1`
`instance.EvalSha(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`100.0%`	`1/1`
`instance.Get(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`100.0%`	`1/1`
`instance.ZRem(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`100.0%`	`1/1`
`instance.ZAdd(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`100.0%`	`1/1`
`instance.XClaim(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`100.0%`	`1/1`
`instance.XPendingExt(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`100.0%`	`1/1`
`instance.XReadGroup(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`100.0%`	`1/1`
`instance.XGroupCreateMkStream(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`100.0%`	`1/1`
`instance.Eval(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`100.0%`	`1/1`
`instance.Keys(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`100.0%`	`1/1`
`addInstance(...)`	`github.com/wfusion/gofusion/redis/construct.go`	`91.3%`	`21/23`
`@31:9(...)`	`github.com/wfusion/gofusion/redis/construct.go`	`88.9%`	`8/9`
`Use(...)`	`github.com/wfusion/gofusion/redis/redis.go`	`80.0%`	`8/10`
`metricRedisLatency(...)`	`github.com/wfusion/gofusion/redis/metrics.go`	`66.7%`	`2/3`
`metricRedisStats(...)`	`github.com/wfusion/gofusion/redis/metrics.go`	`66.7%`	`2/3`
`@61:21(...)`	`github.com/wfusion/gofusion/redis/metrics.go`	`51.6%`	`16/31`
`@114:21(...)`	`github.com/wfusion/gofusion/redis/metrics.go`	`50.0%`	`10/20`
`instance.Persist(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ExpireNX(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ExpireXX(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ExpireGT(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ExpireLT(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ExpireTime(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.Migrate(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.Move(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ObjectRefCount(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ObjectEncoding(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ObjectIdleTime(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ExpireAt(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.PExpire(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.PExpireAt(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.PExpireTime(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.PTTL(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.RandomKey(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.Rename(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.RenameNX(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.Restore(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.RestoreReplace(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.Sort(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SortRO(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SortStore(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SortInterfaces(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.Touch(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.TTL(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.Type(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.Append(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.Decr(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.DecrBy(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.Expire(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.GetRange(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.GetSet(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.GetEx(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.GetDel(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.Incr(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.IncrBy(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.IncrByFloat(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.Exists(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.MSet(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.MSetNX(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.Dump(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SetArgs(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SetEx(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.Unlink(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SetXX(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SetRange(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.StrLen(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.Copy(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.GetBit(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SetBit(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.BitCount(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.BitOpAnd(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.BitOpOr(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.BitOpXor(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.BitOpNot(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.BitPos(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.BitPosSpan(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.BitField(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.Scan(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ScanType(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SScan(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.HScan(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZScan(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.HDel(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.HExists(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.HGet(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.HGetAll(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.HIncrBy(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.HIncrByFloat(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.HKeys(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.HLen(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.HMGet(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.HSet(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.HMSet(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.HSetNX(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.HVals(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.HRandField(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.HRandFieldWithValues(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.BLPop(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.BLMPop(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.BRPop(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.BRPopLPush(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.LCS(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.LIndex(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.LMPop(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.LInsert(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.LInsertBefore(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.LInsertAfter(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.LLen(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.LPop(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.LPopCount(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.LPos(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.LPosCount(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.LPush(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.LPushX(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.LRange(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.LRem(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.LSet(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.Quit(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.RPop(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.RPopCount(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.RPopLPush(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.RPush(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.RPushX(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.LMove(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.BLMove(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.Ping(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SCard(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SDiff(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SDiffStore(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SInter(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SInterCard(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SInterStore(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SIsMember(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SMIsMember(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SMembers(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SMembersMap(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SMove(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SPop(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SPopN(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SRandMember(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SRandMemberN(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SRem(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SUnion(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SUnionStore(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.Echo(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.XDel(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.XLen(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.XRange(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.XRangeN(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.XRevRange(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.XRevRangeN(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.XRead(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.XReadStreams(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.XGroupCreate(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClientGetName(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.XGroupSetID(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.XGroupDestroy(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.XGroupCreateConsumer(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.XGroupDelConsumer(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.CommandGetKeysAndFlags(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.LTrim(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.XPending(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.CommandGetKeys(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.CommandList(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.XClaimJustID(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.XAutoClaim(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.XAutoClaimJustID(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.XTrimMaxLen(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.XTrimMaxLenApprox(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.XTrimMinID(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.XTrimMinIDApprox(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.XInfoGroups(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.XInfoStream(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.XInfoStreamFull(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.XInfoConsumers(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.BZPopMax(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.BZPopMin(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.BZMPop(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.Command(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZAddLT(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZAddGT(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZAddNX(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZAddXX(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZAddArgs(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZAddArgsIncr(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZCard(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZCount(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZLexCount(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZIncrBy(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZInter(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZInterWithScores(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZInterCard(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZInterStore(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZMPop(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZMScore(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZPopMax(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZPopMin(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZRange(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZRangeWithScores(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZRangeByScore(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZRangeByLex(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZRangeByScoreWithScores(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZRangeArgs(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZRangeArgsWithScores(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZRangeStore(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZRank(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZRankWithScore(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.TxPipeline(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZRemRangeByRank(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZRemRangeByScore(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZRemRangeByLex(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZRevRange(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZRevRangeWithScores(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZRevRangeByScore(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZRevRangeByLex(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZRevRangeByScoreWithScores(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZRevRank(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZRevRankWithScore(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZScore(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZUnionStore(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZRandMember(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZRandMemberWithScores(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZUnion(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZUnionWithScores(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZDiff(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZDiffWithScores(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ZDiffStore(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.PFAdd(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.PFCount(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.PFMerge(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.BgRewriteAOF(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.BgSave(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClientKill(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClientKillByFilter(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClientList(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClientPause(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClientUnpause(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClientID(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClientUnblock(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClientUnblockWithError(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClientInfo(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ConfigGet(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ConfigResetStat(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ConfigSet(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ConfigRewrite(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.DBSize(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.FlushAll(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.FlushAllAsync(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.FlushDB(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.FlushDBAsync(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.Info(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.LastSave(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.Save(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.Shutdown(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ShutdownSave(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ShutdownNoSave(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SlaveOf(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SlowLogGet(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.Time(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.DebugObject(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ReadOnly(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ReadWrite(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.MemoryUsage(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.TxPipelined(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.Pipelined(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.EvalRO(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.EvalShaRO(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ScriptExists(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ScriptFlush(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ScriptKill(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ScriptLoad(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.FunctionLoad(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.FunctionLoadReplace(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.FunctionDelete(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.FunctionFlush(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.FunctionKill(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.FunctionFlushAsync(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.FunctionList(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.FunctionDump(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.FunctionRestore(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.FunctionStats(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.FCall(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.FCallRo(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.FCallRO(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.Publish(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SPublish(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.PubSubChannels(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.PubSubNumSub(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.PubSubNumPat(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.PubSubShardChannels(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.PubSubShardNumSub(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClusterMyShardID(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClusterSlots(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClusterShards(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClusterLinks(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClusterNodes(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClusterMeet(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClusterForget(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClusterReplicate(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClusterResetSoft(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClusterResetHard(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClusterInfo(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClusterKeySlot(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClusterGetKeysInSlot(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClusterCountFailureReports(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClusterCountKeysInSlot(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClusterDelSlots(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClusterDelSlotsRange(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClusterSaveConfig(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClusterSlaves(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClusterFailover(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClusterAddSlots(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ClusterAddSlotsRange(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.GeoAdd(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.GeoPos(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.GeoRadius(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.GeoRadiusStore(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.GeoRadiusByMember(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.GeoRadiusByMemberStore(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.GeoSearch(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.GeoSearchLocation(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.GeoSearchStore(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.GeoDist(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.GeoHash(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ACLDryRun(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.ModuleLoadex(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.AddHook(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.Watch(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.Do(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.Process(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`@83:22(...)`	`github.com/wfusion/gofusion/redis/construct.go`	`0.0%`	`0/1`
`instance.PSubscribe(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.SSubscribe(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.Close(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`
`instance.PoolStats(...)`	`github.com/wfusion/gofusion/redis/wrap.go`	`0.0%`	`0/1`

func startDaemonRoutines

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/metrics.go:

func startDaemonRoutines(ctx context.Context, appName, name string, conf *Conf) {
        ticker := time.Tick(time.Second * 5)
        app := config.Use(appName).AppName()
        labels := []metrics.Label{
                {Key: "config", Value: name},
                {Key: "database", Value: cast.ToString(conf.DB)},
        }

        log.Printf("%v [Gofusion] %s %s %s metrics start", syscall.Getpid(), app, config.ComponentRedis, name)
        for {
                select {
                case <-ctx.Done():
                        log.Printf("%v [Gofusion] %s %s %s metrics exited",
                                syscall.Getpid(), app, config.ComponentRedis, name)
                        return
                case <-ticker:
                        go metricRedisStats(ctx, appName, name, labels)
                        go metricRedisLatency(ctx, appName, name, labels)
                }
        }
}

func Construct

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/construct.go:

func Construct(ctx context.Context, confs map[string]*Conf, opts ...utils.OptionExtender) func() {
        opt := utils.ApplyOptions[config.InitOption](opts...)
        optU := utils.ApplyOptions[useOption](opts...)
        if opt.AppName == "" {
                opt.AppName = optU.appName
        }

        for name, conf := range confs {
                addInstance(ctx, name, conf, opt)
        }
        return func() {
                rwlock.Lock()
                defer rwlock.Unlock()

                pid := syscall.Getpid()
                app := config.Use(opt.AppName).AppName()
                if appInstances != nil {
                        for name, instance := range appInstances[opt.AppName] {
                                if err := instance.GetProxy().Close(); err != nil {
                                        log.Printf("%v [Gofusion] %s %s %s close error: %s",
                                                pid, app, config.ComponentRedis, name, err)
                                }
                        }
                        delete(appInstances, opt.AppName)
                }
        }
}

func instance.XAdd

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

452	`func (i instance) XAdd(ctx context.Context, a rdsDrv.XAddArgs) *rdsDrv.StringCmd {`
453	`return i.GetProxy().XAdd(ctx, a)`
454	`}`

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

1015	`func (i instance) Subscribe(ctx context.Context, channels ...string) rdsDrv.PubSub {`
1016	`return i.GetProxy().Subscribe(ctx, channels...)`
1017	`}`

func init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/construct.go:

89	`func init() {`
90	`config.AddComponent(config.ComponentRedis, Construct)`
91	`}`

func instance.MGet

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

182	`func (i instance) MGet(ctx context.Context, keys ...string) rdsDrv.SliceCmd {`
183	`return i.GetProxy().MGet(ctx, keys...)`
184	`}`

func instance.Set

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

191	`func (i instance) Set(ctx context.Context, key string, value any, expiration time.Duration) rdsDrv.StatusCmd {`
192	`return i.GetProxy().Set(ctx, key, value, expiration)`
193	`}`

func instance.SetNX

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

201	`func (i instance) SetNX(ctx context.Context, key string, value any, expiration time.Duration) rdsDrv.BoolCmd {`
202	`return i.GetProxy().SetNX(ctx, key, value, expiration)`
203	`}`

func instance.Del

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

46	`func (i instance) Del(ctx context.Context, keys ...string) rdsDrv.IntCmd {`
47	`return i.GetProxy().Del(ctx, keys...)`
48	`}`

func instance.XAck

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

501	`func (i instance) XAck(ctx context.Context, stream, group string, ids ...string) rdsDrv.IntCmd {`
502	`return i.GetProxy().XAck(ctx, stream, group, ids...)`
503	`}`

func instance.GetProxy

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/redis.go:

25	`func (i *instance) GetProxy() rdsDrv.UniversalClient {`
26	`return i.redis.GetProxy()`
27	`}`

func AppName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/redis.go:

func AppName(name string) utils.OptionFunc[useOption] {
        return func(o *useOption) {
                o.appName = name
        }
}

func @39:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/redis.go:

39	`func(o *useOption) {`
40	`o.appName = name`
41	`}`

func instance.SAdd

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

395	`func (i instance) SAdd(ctx context.Context, key string, members ...any) rdsDrv.IntCmd {`
396	`return i.GetProxy().SAdd(ctx, key, members...)`
397	`}`

func instance.Pipeline

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

10	`func (i *instance) Pipeline() rdsDrv.Pipeliner {`
11	`return i.GetProxy().Pipeline()`
12	`}`

func instance.EvalSha

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

811	`func (i instance) EvalSha(ctx context.Context, sha1 string, keys []string, args ...any) rdsDrv.Cmd {`
812	`return i.GetProxy().EvalSha(ctx, sha1, keys, args...)`
813	`}`

func instance.Get

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

158	`func (i instance) Get(ctx context.Context, key string) rdsDrv.StringCmd {`
159	`return i.GetProxy().Get(ctx, key)`
160	`}`

func instance.ZRem

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

644	`func (i instance) ZRem(ctx context.Context, key string, members ...any) rdsDrv.IntCmd {`
645	`return i.GetProxy().ZRem(ctx, key, members...)`
646	`}`

func instance.ZAdd

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

556	`func (i instance) ZAdd(ctx context.Context, key string, members ...rdsDrv.Z) rdsDrv.IntCmd {`
557	`return i.GetProxy().ZAdd(ctx, key, members...)`
558	`}`

func instance.XClaim

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

510	`func (i instance) XClaim(ctx context.Context, a rdsDrv.XClaimArgs) *rdsDrv.XMessageSliceCmd {`
511	`return i.GetProxy().XClaim(ctx, a)`
512	`}`

func instance.XPendingExt

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

507	`func (i instance) XPendingExt(ctx context.Context, a rdsDrv.XPendingExtArgs) *rdsDrv.XPendingExtCmd {`
508	`return i.GetProxy().XPendingExt(ctx, a)`
509	`}`

func instance.XReadGroup

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

498	`func (i instance) XReadGroup(ctx context.Context, a rdsDrv.XReadGroupArgs) *rdsDrv.XStreamSliceCmd {`
499	`return i.GetProxy().XReadGroup(ctx, a)`
500	`}`

func instance.XGroupCreateMkStream

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

483	`func (i instance) XGroupCreateMkStream(ctx context.Context, stream, group, start string) rdsDrv.StatusCmd {`
484	`return i.GetProxy().XGroupCreateMkStream(ctx, stream, group, start)`
485	`}`

func instance.Eval

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

808	`func (i instance) Eval(ctx context.Context, script string, keys []string, args ...any) rdsDrv.Cmd {`
809	`return i.GetProxy().Eval(ctx, script, keys, args...)`
810	`}`

func instance.Keys

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

79	`func (i instance) Keys(ctx context.Context, pattern string) rdsDrv.StringSliceCmd {`
80	`return i.GetProxy().Keys(ctx, pattern)`
81	`}`

func addInstance

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/construct.go:

func addInstance(ctx context.Context, name string, conf *Conf, opt *config.InitOption) {
        var hooks []rdsDrv.Hook
        for _, hookLoc := range conf.Hooks {
                if hookType := inspect.TypeOf(hookLoc); hookType != nil {
                        hookValue := reflect.New(hookType)
                        if hookValue.Type().Implements(customLoggerType) {
                                logger := fusLog.Use(conf.LogInstance, fusLog.AppName(opt.AppName))
                                hookValue.Interface().(customLogger).Init(logger, opt.AppName, name)
                        }

                        hooks = append(hooks, hookValue.Interface().(rdsDrv.Hook))
                }
        }

        // conf.Option.Password = config.CryptoDecryptFunc()(conf.Option.Password)
        rdsCli, err := redis.Default.New(ctx, conf.Option, redis.WithHook(hooks))
        if err != nil {
                panic(err)
        }

        rwlock.Lock()
        defer rwlock.Unlock()
        if appInstances == nil {
                appInstances = make(map[string]map[string]*instance)
        }
        if appInstances[opt.AppName] == nil {
                appInstances[opt.AppName] = make(map[string]*instance)
        }
        if _, ok := appInstances[opt.AppName][name]; ok {
                panic(ErrDuplicatedName)
        }
        appInstances[opt.AppName][name] = &instance{name: name, redis: rdsCli}

        if opt.DI != nil {
                opt.DI.MustProvide(func() rdsDrv.UniversalClient { return Use(ctx, name, AppName(opt.AppName)) }, di.Name(name))
        }

        go startDaemonRoutines(ctx, opt.AppName, name, conf)
}

func @31:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/construct.go:

func() {
                rwlock.Lock()
                defer rwlock.Unlock()

                pid := syscall.Getpid()
                app := config.Use(opt.AppName).AppName()
                if appInstances != nil {
                        for name, instance := range appInstances[opt.AppName] {
                                if err := instance.GetProxy().Close(); err != nil {
                                        log.Printf("%v [Gofusion] %s %s %s close error: %s",
                                                pid, app, config.ComponentRedis, name, err)
                                }
                        }
                        delete(appInstances, opt.AppName)
                }
        }

func Use

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/redis.go:

func Use(ctx context.Context, name string, opts ...utils.OptionExtender) rdsDrv.UniversalClient {
        opt := utils.ApplyOptions[useOption](opts...)

        rwlock.RLock()
        defer rwlock.RUnlock()
        instances, ok := appInstances[opt.appName]
        if !ok {
                panic(errors.Errorf("redis instance not found for app: %s", opt.appName))
        }
        instance, ok := instances[name]
        if !ok {
                panic(errors.Errorf("redis instance not found for name: %s", name))
        }
        return &Redis{UniversalClient: instance, Name: name}
}

func metricRedisLatency

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/metrics.go:

func metricRedisLatency(ctx context.Context, appName, name string, labels []metrics.Label) {
        select {
        case <-ctx.Done():
                return
        default:

        }

        _, _ = utils.Catch(func() {
                rwlock.RLock()
                defer rwlock.RUnlock()
                instances, ok := appInstances[appName]
                if !ok {
                        return
                }
                instance, ok := instances[name]
                if !ok {
                        return
                }

                rdsCli := instance.GetProxy()
                begin := time.Now()
                if err := rdsCli.Ping(ctx); err != nil {
                        return
                }

                latency := float64(time.Since(begin)) / float64(time.Millisecond)
                latencyKey := append([]string{config.Use(appName).AppName()}, metricsLatencyKey...)
                for _, m := range metrics.Internal(metrics.AppName(appName)) {
                        select {
                        case <-ctx.Done():
                                return
                        default:
                                if m.IsEnableServiceLabel() {
                                        m.AddSample(ctx, latencyKey, latency,
                                                metrics.Labels(labels),
                                                metrics.PrometheusBuckets(metricsLatencyBuckets),
                                        )
                                } else {
                                        m.AddSample(ctx, metricsLatencyKey, latency,
                                                metrics.Labels(labels),
                                                metrics.PrometheusBuckets(metricsLatencyBuckets),
                                        )
                                }
                        }
                }
        })
}

func metricRedisStats

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/metrics.go:

func metricRedisStats(ctx context.Context, appName, name string, labels []metrics.Label) {
        select {
        case <-ctx.Done():
                return
        default:

        }

        _, _ = utils.Catch(func() {
                rwlock.RLock()
                defer rwlock.RUnlock()
                _ = appInstances[appName][name].GetProxy()
                instances, ok := appInstances[appName]
                if !ok {
                        return
                }
                instance, ok := instances[name]
                if !ok {
                        return
                }

                app := config.Use(appName).AppName()
                idleKey := append([]string{app}, metricsPoolIdleKey...)
                staleKey := append([]string{app}, metricsPoolStaleKey...)
                totalKey := append([]string{app}, metricsPoolTotalKey...)
                hitsKey := append([]string{app}, metricsPoolHitsKey...)
                missesKey := append([]string{app}, metricsPoolMissesKey...)

                rdsCli := instance.GetProxy()
                stats := rdsCli.PoolStats()
                for _, m := range metrics.Internal(metrics.AppName(appName)) {
                        select {
                        case <-ctx.Done():
                                return
                        default:
                                if m.IsEnableServiceLabel() {
                                        m.SetGauge(ctx, idleKey, float64(stats.IdleConns), metrics.Labels(labels))
                                        m.SetGauge(ctx, staleKey, float64(stats.StaleConns), metrics.Labels(labels))
                                        m.SetGauge(ctx, totalKey, float64(stats.TotalConns), metrics.Labels(labels))
                                        m.SetGauge(ctx, hitsKey, float64(stats.Hits), metrics.Labels(labels))
                                        m.SetGauge(ctx, missesKey, float64(stats.Misses), metrics.Labels(labels))
                                } else {
                                        m.SetGauge(ctx, metricsPoolIdleKey, float64(stats.IdleConns), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsPoolStaleKey, float64(stats.StaleConns), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsPoolTotalKey, float64(stats.TotalConns), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsPoolHitsKey, float64(stats.Hits), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsPoolMissesKey, float64(stats.Misses), metrics.Labels(labels))
                                }
                        }
                }
        })
}

func @61:21

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/metrics.go:

func() {
                rwlock.RLock()
                defer rwlock.RUnlock()
                _ = appInstances[appName][name].GetProxy()
                instances, ok := appInstances[appName]
                if !ok {
                        return
                }
                instance, ok := instances[name]
                if !ok {
                        return
                }

                app := config.Use(appName).AppName()
                idleKey := append([]string{app}, metricsPoolIdleKey...)
                staleKey := append([]string{app}, metricsPoolStaleKey...)
                totalKey := append([]string{app}, metricsPoolTotalKey...)
                hitsKey := append([]string{app}, metricsPoolHitsKey...)
                missesKey := append([]string{app}, metricsPoolMissesKey...)

                rdsCli := instance.GetProxy()
                stats := rdsCli.PoolStats()
                for _, m := range metrics.Internal(metrics.AppName(appName)) {
                        select {
                        case <-ctx.Done():
                                return
                        default:
                                if m.IsEnableServiceLabel() {
                                        m.SetGauge(ctx, idleKey, float64(stats.IdleConns), metrics.Labels(labels))
                                        m.SetGauge(ctx, staleKey, float64(stats.StaleConns), metrics.Labels(labels))
                                        m.SetGauge(ctx, totalKey, float64(stats.TotalConns), metrics.Labels(labels))
                                        m.SetGauge(ctx, hitsKey, float64(stats.Hits), metrics.Labels(labels))
                                        m.SetGauge(ctx, missesKey, float64(stats.Misses), metrics.Labels(labels))
                                } else {
                                        m.SetGauge(ctx, metricsPoolIdleKey, float64(stats.IdleConns), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsPoolStaleKey, float64(stats.StaleConns), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsPoolTotalKey, float64(stats.TotalConns), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsPoolHitsKey, float64(stats.Hits), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsPoolMissesKey, float64(stats.Misses), metrics.Labels(labels))
                                }
                        }
                }
        }

func @114:21

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/metrics.go:

func() {
                rwlock.RLock()
                defer rwlock.RUnlock()
                instances, ok := appInstances[appName]
                if !ok {
                        return
                }
                instance, ok := instances[name]
                if !ok {
                        return
                }

                rdsCli := instance.GetProxy()
                begin := time.Now()
                if err := rdsCli.Ping(ctx); err != nil {
                        return
                }

                latency := float64(time.Since(begin)) / float64(time.Millisecond)
                latencyKey := append([]string{config.Use(appName).AppName()}, metricsLatencyKey...)
                for _, m := range metrics.Internal(metrics.AppName(appName)) {
                        select {
                        case <-ctx.Done():
                                return
                        default:
                                if m.IsEnableServiceLabel() {
                                        m.AddSample(ctx, latencyKey, latency,
                                                metrics.Labels(labels),
                                                metrics.PrometheusBuckets(metricsLatencyBuckets),
                                        )
                                } else {
                                        m.AddSample(ctx, metricsLatencyKey, latency,
                                                metrics.Labels(labels),
                                                metrics.PrometheusBuckets(metricsLatencyBuckets),
                                        )
                                }
                        }
                }
        }

func instance.Persist

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

98	`func (i instance) Persist(ctx context.Context, key string) rdsDrv.BoolCmd {`
99	`return i.GetProxy().Persist(ctx, key)`
100	`}`

func instance.ExpireNX

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

67	`func (i instance) ExpireNX(ctx context.Context, key string, expiration time.Duration) rdsDrv.BoolCmd {`
68	`return i.GetProxy().ExpireNX(ctx, key, expiration)`
69	`}`

func instance.ExpireXX

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

70	`func (i instance) ExpireXX(ctx context.Context, key string, expiration time.Duration) rdsDrv.BoolCmd {`
71	`return i.GetProxy().ExpireXX(ctx, key, expiration)`
72	`}`

func instance.ExpireGT

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

73	`func (i instance) ExpireGT(ctx context.Context, key string, expiration time.Duration) rdsDrv.BoolCmd {`
74	`return i.GetProxy().ExpireGT(ctx, key, expiration)`
75	`}`

func instance.ExpireLT

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

76	`func (i instance) ExpireLT(ctx context.Context, key string, expiration time.Duration) rdsDrv.BoolCmd {`
77	`return i.GetProxy().ExpireLT(ctx, key, expiration)`
78	`}`

func instance.ExpireTime

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

64	`func (i instance) ExpireTime(ctx context.Context, key string) rdsDrv.DurationCmd {`
65	`return i.GetProxy().ExpireTime(ctx, key)`
66	`}`

func instance.Migrate

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

82	`func (i *instance) Migrate(ctx context.Context, host, port, key string, db int,`
83	`timeout time.Duration) *rdsDrv.StatusCmd {`
84	`return i.GetProxy().Migrate(ctx, host, port, key, db, timeout)`
85	`}`

func instance.Move

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

86	`func (i instance) Move(ctx context.Context, key string, db int) rdsDrv.BoolCmd {`
87	`return i.GetProxy().Move(ctx, key, db)`
88	`}`

func instance.ObjectRefCount

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

89	`func (i instance) ObjectRefCount(ctx context.Context, key string) rdsDrv.IntCmd {`
90	`return i.GetProxy().ObjectRefCount(ctx, key)`
91	`}`

func instance.ObjectEncoding

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

92	`func (i instance) ObjectEncoding(ctx context.Context, key string) rdsDrv.StringCmd {`
93	`return i.GetProxy().ObjectEncoding(ctx, key)`
94	`}`

func instance.ObjectIdleTime

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

95	`func (i instance) ObjectIdleTime(ctx context.Context, key string) rdsDrv.DurationCmd {`
96	`return i.GetProxy().ObjectIdleTime(ctx, key)`
97	`}`

func instance.ExpireAt

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

61	`func (i instance) ExpireAt(ctx context.Context, key string, tm time.Time) rdsDrv.BoolCmd {`
62	`return i.GetProxy().ExpireAt(ctx, key, tm)`
63	`}`

func instance.PExpire

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

101	`func (i instance) PExpire(ctx context.Context, key string, expiration time.Duration) rdsDrv.BoolCmd {`
102	`return i.GetProxy().PExpire(ctx, key, expiration)`
103	`}`

func instance.PExpireAt

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

104	`func (i instance) PExpireAt(ctx context.Context, key string, tm time.Time) rdsDrv.BoolCmd {`
105	`return i.GetProxy().PExpireAt(ctx, key, tm)`
106	`}`

func instance.PExpireTime

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

107	`func (i instance) PExpireTime(ctx context.Context, key string) rdsDrv.DurationCmd {`
108	`return i.GetProxy().PExpireTime(ctx, key)`
109	`}`

func instance.PTTL

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

110	`func (i instance) PTTL(ctx context.Context, key string) rdsDrv.DurationCmd {`
111	`return i.GetProxy().PTTL(ctx, key)`
112	`}`

func instance.RandomKey

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

113	`func (i instance) RandomKey(ctx context.Context) rdsDrv.StringCmd {`
114	`return i.GetProxy().RandomKey(ctx)`
115	`}`

func instance.Rename

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

116	`func (i instance) Rename(ctx context.Context, key, newkey string) rdsDrv.StatusCmd {`
117	`return i.GetProxy().Rename(ctx, key, newkey)`
118	`}`

func instance.RenameNX

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

119	`func (i instance) RenameNX(ctx context.Context, key, newkey string) rdsDrv.BoolCmd {`
120	`return i.GetProxy().RenameNX(ctx, key, newkey)`
121	`}`

func instance.Restore

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

122	`func (i instance) Restore(ctx context.Context, key string, ttl time.Duration, value string) rdsDrv.StatusCmd {`
123	`return i.GetProxy().Restore(ctx, key, ttl, value)`
124	`}`

func instance.RestoreReplace

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

125	`func (i instance) RestoreReplace(ctx context.Context, key string, ttl time.Duration, value string) rdsDrv.StatusCmd {`
126	`return i.GetProxy().RestoreReplace(ctx, key, ttl, value)`
127	`}`

func instance.Sort

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

128	`func (i instance) Sort(ctx context.Context, key string, sort rdsDrv.Sort) *rdsDrv.StringSliceCmd {`
129	`return i.GetProxy().Sort(ctx, key, sort)`
130	`}`

func instance.SortRO

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

131	`func (i instance) SortRO(ctx context.Context, key string, sort rdsDrv.Sort) *rdsDrv.StringSliceCmd {`
132	`return i.GetProxy().SortRO(ctx, key, sort)`
133	`}`

func instance.SortStore

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

134	`func (i instance) SortStore(ctx context.Context, key, store string, sort rdsDrv.Sort) *rdsDrv.IntCmd {`
135	`return i.GetProxy().SortStore(ctx, key, store, sort)`
136	`}`

func instance.SortInterfaces

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

137	`func (i instance) SortInterfaces(ctx context.Context, key string, sort rdsDrv.Sort) *rdsDrv.SliceCmd {`
138	`return i.GetProxy().SortInterfaces(ctx, key, sort)`
139	`}`

func instance.Touch

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

140	`func (i instance) Touch(ctx context.Context, keys ...string) rdsDrv.IntCmd {`
141	`return i.GetProxy().Touch(ctx, keys...)`
142	`}`

func instance.TTL

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

143	`func (i instance) TTL(ctx context.Context, key string) rdsDrv.DurationCmd {`
144	`return i.GetProxy().TTL(ctx, key)`
145	`}`

func instance.Type

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

146	`func (i instance) Type(ctx context.Context, key string) rdsDrv.StatusCmd {`
147	`return i.GetProxy().Type(ctx, key)`
148	`}`

func instance.Append

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

149	`func (i instance) Append(ctx context.Context, key, value string) rdsDrv.IntCmd {`
150	`return i.GetProxy().Append(ctx, key, value)`
151	`}`

func instance.Decr

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

152	`func (i instance) Decr(ctx context.Context, key string) rdsDrv.IntCmd {`
153	`return i.GetProxy().Decr(ctx, key)`
154	`}`

func instance.DecrBy

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

155	`func (i instance) DecrBy(ctx context.Context, key string, decrement int64) rdsDrv.IntCmd {`
156	`return i.GetProxy().DecrBy(ctx, key, decrement)`
157	`}`

func instance.Expire

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

58	`func (i instance) Expire(ctx context.Context, key string, expiration time.Duration) rdsDrv.BoolCmd {`
59	`return i.GetProxy().Expire(ctx, key, expiration)`
60	`}`

func instance.GetRange

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

161	`func (i instance) GetRange(ctx context.Context, key string, start, end int64) rdsDrv.StringCmd {`
162	`return i.GetProxy().GetRange(ctx, key, start, end)`
163	`}`

func instance.GetSet

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

164	`func (i instance) GetSet(ctx context.Context, key string, value any) rdsDrv.StringCmd {`
165	`return i.GetProxy().GetSet(ctx, key, value)`
166	`}`

func instance.GetEx

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

167	`func (i instance) GetEx(ctx context.Context, key string, expiration time.Duration) rdsDrv.StringCmd {`
168	`return i.GetProxy().GetEx(ctx, key, expiration)`
169	`}`

func instance.GetDel

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

170	`func (i instance) GetDel(ctx context.Context, key string) rdsDrv.StringCmd {`
171	`return i.GetProxy().GetDel(ctx, key)`
172	`}`

func instance.Incr

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

173	`func (i instance) Incr(ctx context.Context, key string) rdsDrv.IntCmd {`
174	`return i.GetProxy().Incr(ctx, key)`
175	`}`

func instance.IncrBy

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

176	`func (i instance) IncrBy(ctx context.Context, key string, value int64) rdsDrv.IntCmd {`
177	`return i.GetProxy().IncrBy(ctx, key, value)`
178	`}`

func instance.IncrByFloat

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

179	`func (i instance) IncrByFloat(ctx context.Context, key string, value float64) rdsDrv.FloatCmd {`
180	`return i.GetProxy().IncrByFloat(ctx, key, value)`
181	`}`

func instance.Exists

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

55	`func (i instance) Exists(ctx context.Context, keys ...string) rdsDrv.IntCmd {`
56	`return i.GetProxy().Exists(ctx, keys...)`
57	`}`

func instance.MSet

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

185	`func (i instance) MSet(ctx context.Context, values ...any) rdsDrv.StatusCmd {`
186	`return i.GetProxy().MSet(ctx, values...)`
187	`}`

func instance.MSetNX

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

188	`func (i instance) MSetNX(ctx context.Context, values ...any) rdsDrv.BoolCmd {`
189	`return i.GetProxy().MSetNX(ctx, values...)`
190	`}`

func instance.Dump

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

52	`func (i instance) Dump(ctx context.Context, key string) rdsDrv.StringCmd {`
53	`return i.GetProxy().Dump(ctx, key)`
54	`}`

func instance.SetArgs

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

194	`func (i instance) SetArgs(ctx context.Context, key string, value any, a rdsDrv.SetArgs) rdsDrv.StatusCmd {`
195	`return i.GetProxy().SetArgs(ctx, key, value, a)`
196	`}`

func instance.SetEx

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

197	`func (i *instance) SetEx(ctx context.Context, key string, value any,`
198	`expiration time.Duration) *rdsDrv.StatusCmd {`
199	`return i.GetProxy().SetEx(ctx, key, value, expiration)`
200	`}`

func instance.Unlink

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

49	`func (i instance) Unlink(ctx context.Context, keys ...string) rdsDrv.IntCmd {`
50	`return i.GetProxy().Unlink(ctx, keys...)`
51	`}`

func instance.SetXX

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

204	`func (i instance) SetXX(ctx context.Context, key string, value any, expiration time.Duration) rdsDrv.BoolCmd {`
205	`return i.GetProxy().SetXX(ctx, key, value, expiration)`
206	`}`

func instance.SetRange

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

207	`func (i instance) SetRange(ctx context.Context, key string, offset int64, value string) rdsDrv.IntCmd {`
208	`return i.GetProxy().SetRange(ctx, key, offset, value)`
209	`}`

func instance.StrLen

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

210	`func (i instance) StrLen(ctx context.Context, key string) rdsDrv.IntCmd {`
211	`return i.GetProxy().StrLen(ctx, key)`
212	`}`

func instance.Copy

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

213	`func (i instance) Copy(ctx context.Context, sourceKey string, destKey string, db int, replace bool) rdsDrv.IntCmd {`
214	`return i.GetProxy().Copy(ctx, sourceKey, destKey, db, replace)`
215	`}`

func instance.GetBit

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

216	`func (i instance) GetBit(ctx context.Context, key string, offset int64) rdsDrv.IntCmd {`
217	`return i.GetProxy().GetBit(ctx, key, offset)`
218	`}`

func instance.SetBit

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

219	`func (i instance) SetBit(ctx context.Context, key string, offset int64, value int) rdsDrv.IntCmd {`
220	`return i.GetProxy().SetBit(ctx, key, offset, value)`
221	`}`

func instance.BitCount

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

222	`func (i instance) BitCount(ctx context.Context, key string, bitCount rdsDrv.BitCount) *rdsDrv.IntCmd {`
223	`return i.GetProxy().BitCount(ctx, key, bitCount)`
224	`}`

func instance.BitOpAnd

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

225	`func (i instance) BitOpAnd(ctx context.Context, destKey string, keys ...string) rdsDrv.IntCmd {`
226	`return i.GetProxy().BitOpAnd(ctx, destKey, keys...)`
227	`}`

func instance.BitOpOr

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

228	`func (i instance) BitOpOr(ctx context.Context, destKey string, keys ...string) rdsDrv.IntCmd {`
229	`return i.GetProxy().BitOpOr(ctx, destKey, keys...)`
230	`}`

func instance.BitOpXor

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

231	`func (i instance) BitOpXor(ctx context.Context, destKey string, keys ...string) rdsDrv.IntCmd {`
232	`return i.GetProxy().BitOpXor(ctx, destKey, keys...)`
233	`}`

func instance.BitOpNot

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

234	`func (i instance) BitOpNot(ctx context.Context, destKey string, key string) rdsDrv.IntCmd {`
235	`return i.GetProxy().BitOpNot(ctx, destKey, key)`
236	`}`

func instance.BitPos

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

237	`func (i instance) BitPos(ctx context.Context, key string, bit int64, pos ...int64) rdsDrv.IntCmd {`
238	`return i.GetProxy().BitPos(ctx, key, bit, pos...)`
239	`}`

func instance.BitPosSpan

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

240	`func (i instance) BitPosSpan(ctx context.Context, key string, bit int8, start, end int64, span string) rdsDrv.IntCmd {`
241	`return i.GetProxy().BitPosSpan(ctx, key, bit, start, end, span)`
242	`}`

func instance.BitField

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

243	`func (i instance) BitField(ctx context.Context, key string, args ...any) rdsDrv.IntSliceCmd {`
244	`return i.GetProxy().BitField(ctx, key, args...)`
245	`}`

func instance.Scan

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

246	`func (i instance) Scan(ctx context.Context, cursor uint64, match string, count int64) rdsDrv.ScanCmd {`
247	`return i.GetProxy().Scan(ctx, cursor, match, count)`
248	`}`

func instance.ScanType

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

249	`func (i *instance) ScanType(ctx context.Context, cursor uint64, match string, count int64,`
250	`keyType string) *rdsDrv.ScanCmd {`
251	`return i.GetProxy().ScanType(ctx, cursor, match, count, keyType)`
252	`}`

func instance.SScan

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

253	`func (i instance) SScan(ctx context.Context, key string, cursor uint64, match string, count int64) rdsDrv.ScanCmd {`
254	`return i.GetProxy().SScan(ctx, key, cursor, match, count)`
255	`}`

func instance.HScan

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

256	`func (i instance) HScan(ctx context.Context, key string, cursor uint64, match string, count int64) rdsDrv.ScanCmd {`
257	`return i.GetProxy().HScan(ctx, key, cursor, match, count)`
258	`}`

func instance.ZScan

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

259	`func (i instance) ZScan(ctx context.Context, key string, cursor uint64, match string, count int64) rdsDrv.ScanCmd {`
260	`return i.GetProxy().ZScan(ctx, key, cursor, match, count)`
261	`}`

func instance.HDel

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

262	`func (i instance) HDel(ctx context.Context, key string, fields ...string) rdsDrv.IntCmd {`
263	`return i.GetProxy().HDel(ctx, key, fields...)`
264	`}`

func instance.HExists

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

265	`func (i instance) HExists(ctx context.Context, key, field string) rdsDrv.BoolCmd {`
266	`return i.GetProxy().HExists(ctx, key, field)`
267	`}`

func instance.HGet

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

268	`func (i instance) HGet(ctx context.Context, key, field string) rdsDrv.StringCmd {`
269	`return i.GetProxy().HGet(ctx, key, field)`
270	`}`

func instance.HGetAll

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

271	`func (i instance) HGetAll(ctx context.Context, key string) rdsDrv.MapStringStringCmd {`
272	`return i.GetProxy().HGetAll(ctx, key)`
273	`}`

func instance.HIncrBy

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

274	`func (i instance) HIncrBy(ctx context.Context, key, field string, incr int64) rdsDrv.IntCmd {`
275	`return i.GetProxy().HIncrBy(ctx, key, field, incr)`
276	`}`

func instance.HIncrByFloat

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

277	`func (i instance) HIncrByFloat(ctx context.Context, key, field string, incr float64) rdsDrv.FloatCmd {`
278	`return i.GetProxy().HIncrByFloat(ctx, key, field, incr)`
279	`}`

func instance.HKeys

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

280	`func (i instance) HKeys(ctx context.Context, key string) rdsDrv.StringSliceCmd {`
281	`return i.GetProxy().HKeys(ctx, key)`
282	`}`

func instance.HLen

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

283	`func (i instance) HLen(ctx context.Context, key string) rdsDrv.IntCmd {`
284	`return i.GetProxy().HLen(ctx, key)`
285	`}`

func instance.HMGet

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

286	`func (i instance) HMGet(ctx context.Context, key string, fields ...string) rdsDrv.SliceCmd {`
287	`return i.GetProxy().HMGet(ctx, key, fields...)`
288	`}`

func instance.HSet

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

289	`func (i instance) HSet(ctx context.Context, key string, values ...any) rdsDrv.IntCmd {`
290	`return i.GetProxy().HSet(ctx, key, values...)`
291	`}`

func instance.HMSet

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

292	`func (i instance) HMSet(ctx context.Context, key string, values ...any) rdsDrv.BoolCmd {`
293	`return i.GetProxy().HMSet(ctx, key, values...)`
294	`}`

func instance.HSetNX

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

295	`func (i instance) HSetNX(ctx context.Context, key, field string, value any) rdsDrv.BoolCmd {`
296	`return i.GetProxy().HSetNX(ctx, key, field, value)`
297	`}`

func instance.HVals

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

298	`func (i instance) HVals(ctx context.Context, key string) rdsDrv.StringSliceCmd {`
299	`return i.GetProxy().HVals(ctx, key)`
300	`}`

func instance.HRandField

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

301	`func (i instance) HRandField(ctx context.Context, key string, count int) rdsDrv.StringSliceCmd {`
302	`return i.GetProxy().HRandField(ctx, key, count)`
303	`}`

func instance.HRandFieldWithValues

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

304	`func (i instance) HRandFieldWithValues(ctx context.Context, key string, count int) rdsDrv.KeyValueSliceCmd {`
305	`return i.GetProxy().HRandFieldWithValues(ctx, key, count)`
306	`}`

func instance.BLPop

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

307	`func (i instance) BLPop(ctx context.Context, timeout time.Duration, keys ...string) rdsDrv.StringSliceCmd {`
308	`return i.GetProxy().BLPop(ctx, timeout, keys...)`
309	`}`

func instance.BLMPop

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

310	`func (i *instance) BLMPop(ctx context.Context, timeout time.Duration, direction string,`
311	`count int64, keys ...string) *rdsDrv.KeyValuesCmd {`
312	`return i.GetProxy().BLMPop(ctx, timeout, direction, count, keys...)`
313	`}`

func instance.BRPop

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

314	`func (i instance) BRPop(ctx context.Context, timeout time.Duration, keys ...string) rdsDrv.StringSliceCmd {`
315	`return i.GetProxy().BRPop(ctx, timeout, keys...)`
316	`}`

func instance.BRPopLPush

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

317	`func (i *instance) BRPopLPush(ctx context.Context, source, destination string,`
318	`timeout time.Duration) *rdsDrv.StringCmd {`
319	`return i.GetProxy().BRPopLPush(ctx, source, destination, timeout)`
320	`}`

func instance.LCS

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

321	`func (i instance) LCS(ctx context.Context, q rdsDrv.LCSQuery) *rdsDrv.LCSCmd {`
322	`return i.GetProxy().LCS(ctx, q)`
323	`}`

func instance.LIndex

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

324	`func (i instance) LIndex(ctx context.Context, key string, index int64) rdsDrv.StringCmd {`
325	`return i.GetProxy().LIndex(ctx, key, index)`
326	`}`

func instance.LMPop

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

327	`func (i instance) LMPop(ctx context.Context, direction string, count int64, keys ...string) rdsDrv.KeyValuesCmd {`
328	`return i.GetProxy().LMPop(ctx, direction, count, keys...)`
329	`}`

func instance.LInsert

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

330	`func (i instance) LInsert(ctx context.Context, key, op string, pivot, value any) rdsDrv.IntCmd {`
331	`return i.GetProxy().LInsert(ctx, key, op, pivot, value)`
332	`}`

func instance.LInsertBefore

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

333	`func (i instance) LInsertBefore(ctx context.Context, key string, pivot, value any) rdsDrv.IntCmd {`
334	`return i.GetProxy().LInsertBefore(ctx, key, pivot, value)`
335	`}`

func instance.LInsertAfter

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

336	`func (i instance) LInsertAfter(ctx context.Context, key string, pivot, value any) rdsDrv.IntCmd {`
337	`return i.GetProxy().LInsertAfter(ctx, key, pivot, value)`
338	`}`

func instance.LLen

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

339	`func (i instance) LLen(ctx context.Context, key string) rdsDrv.IntCmd {`
340	`return i.GetProxy().LLen(ctx, key)`
341	`}`

func instance.LPop

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

342	`func (i instance) LPop(ctx context.Context, key string) rdsDrv.StringCmd {`
343	`return i.GetProxy().LPop(ctx, key)`
344	`}`

func instance.LPopCount

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

345	`func (i instance) LPopCount(ctx context.Context, key string, count int) rdsDrv.StringSliceCmd {`
346	`return i.GetProxy().LPopCount(ctx, key, count)`
347	`}`

func instance.LPos

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

348	`func (i instance) LPos(ctx context.Context, key string, value string, args rdsDrv.LPosArgs) rdsDrv.IntCmd {`
349	`return i.GetProxy().LPos(ctx, key, value, args)`
350	`}`

func instance.LPosCount

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

351	`func (i *instance) LPosCount(ctx context.Context, key string, value string, count int64,`
352	`args rdsDrv.LPosArgs) *rdsDrv.IntSliceCmd {`
353	`return i.GetProxy().LPosCount(ctx, key, value, count, args)`
354	`}`

func instance.LPush

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

355	`func (i instance) LPush(ctx context.Context, key string, values ...any) rdsDrv.IntCmd {`
356	`return i.GetProxy().LPush(ctx, key, values...)`
357	`}`

func instance.LPushX

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

358	`func (i instance) LPushX(ctx context.Context, key string, values ...any) rdsDrv.IntCmd {`
359	`return i.GetProxy().LPushX(ctx, key, values...)`
360	`}`

func instance.LRange

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

361	`func (i instance) LRange(ctx context.Context, key string, start, stop int64) rdsDrv.StringSliceCmd {`
362	`return i.GetProxy().LRange(ctx, key, start, stop)`
363	`}`

func instance.LRem

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

364	`func (i instance) LRem(ctx context.Context, key string, count int64, value any) rdsDrv.IntCmd {`
365	`return i.GetProxy().LRem(ctx, key, count, value)`
366	`}`

func instance.LSet

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

367	`func (i instance) LSet(ctx context.Context, key string, index int64, value any) rdsDrv.StatusCmd {`
368	`return i.GetProxy().LSet(ctx, key, index, value)`
369	`}`

func instance.Quit

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

43	`func (i instance) Quit(ctx context.Context) rdsDrv.StatusCmd {`
44	`return i.GetProxy().Quit(ctx)`
45	`}`

func instance.RPop

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

373	`func (i instance) RPop(ctx context.Context, key string) rdsDrv.StringCmd {`
374	`return i.GetProxy().RPop(ctx, key)`
375	`}`

func instance.RPopCount

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

376	`func (i instance) RPopCount(ctx context.Context, key string, count int) rdsDrv.StringSliceCmd {`
377	`return i.GetProxy().RPopCount(ctx, key, count)`
378	`}`

func instance.RPopLPush

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

379	`func (i instance) RPopLPush(ctx context.Context, source, destination string) rdsDrv.StringCmd {`
380	`return i.GetProxy().RPopLPush(ctx, source, destination)`
381	`}`

func instance.RPush

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

382	`func (i instance) RPush(ctx context.Context, key string, values ...any) rdsDrv.IntCmd {`
383	`return i.GetProxy().RPush(ctx, key, values...)`
384	`}`

func instance.RPushX

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

385	`func (i instance) RPushX(ctx context.Context, key string, values ...any) rdsDrv.IntCmd {`
386	`return i.GetProxy().RPushX(ctx, key, values...)`
387	`}`

func instance.LMove

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

388	`func (i instance) LMove(ctx context.Context, source, destination, srcpos, destpos string) rdsDrv.StringCmd {`
389	`return i.GetProxy().LMove(ctx, source, destination, srcpos, destpos)`
390	`}`

func instance.BLMove

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

391	`func (i *instance) BLMove(ctx context.Context, source, destination, srcpos, destpos string,`
392	`timeout time.Duration) *rdsDrv.StringCmd {`
393	`return i.GetProxy().BLMove(ctx, source, destination, srcpos, destpos, timeout)`
394	`}`

func instance.Ping

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

40	`func (i instance) Ping(ctx context.Context) rdsDrv.StatusCmd {`
41	`return i.GetProxy().Ping(ctx)`
42	`}`

func instance.SCard

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

398	`func (i instance) SCard(ctx context.Context, key string) rdsDrv.IntCmd {`
399	`return i.GetProxy().SCard(ctx, key)`
400	`}`

func instance.SDiff

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

401	`func (i instance) SDiff(ctx context.Context, keys ...string) rdsDrv.StringSliceCmd {`
402	`return i.GetProxy().SDiff(ctx, keys...)`
403	`}`

func instance.SDiffStore

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

404	`func (i instance) SDiffStore(ctx context.Context, destination string, keys ...string) rdsDrv.IntCmd {`
405	`return i.GetProxy().SDiffStore(ctx, destination, keys...)`
406	`}`

func instance.SInter

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

407	`func (i instance) SInter(ctx context.Context, keys ...string) rdsDrv.StringSliceCmd {`
408	`return i.GetProxy().SInter(ctx, keys...)`
409	`}`

func instance.SInterCard

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

410	`func (i instance) SInterCard(ctx context.Context, limit int64, keys ...string) rdsDrv.IntCmd {`
411	`return i.GetProxy().SInterCard(ctx, limit, keys...)`
412	`}`

func instance.SInterStore

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

413	`func (i instance) SInterStore(ctx context.Context, destination string, keys ...string) rdsDrv.IntCmd {`
414	`return i.GetProxy().SInterStore(ctx, destination, keys...)`
415	`}`

func instance.SIsMember

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

416	`func (i instance) SIsMember(ctx context.Context, key string, member any) rdsDrv.BoolCmd {`
417	`return i.GetProxy().SIsMember(ctx, key, member)`
418	`}`

func instance.SMIsMember

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

419	`func (i instance) SMIsMember(ctx context.Context, key string, members ...any) rdsDrv.BoolSliceCmd {`
420	`return i.GetProxy().SMIsMember(ctx, key, members...)`
421	`}`

func instance.SMembers

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

422	`func (i instance) SMembers(ctx context.Context, key string) rdsDrv.StringSliceCmd {`
423	`return i.GetProxy().SMembers(ctx, key)`
424	`}`

func instance.SMembersMap

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

425	`func (i instance) SMembersMap(ctx context.Context, key string) rdsDrv.StringStructMapCmd {`
426	`return i.GetProxy().SMembersMap(ctx, key)`
427	`}`

func instance.SMove

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

428	`func (i instance) SMove(ctx context.Context, source, destination string, member any) rdsDrv.BoolCmd {`
429	`return i.GetProxy().SMove(ctx, source, destination, member)`
430	`}`

func instance.SPop

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

431	`func (i instance) SPop(ctx context.Context, key string) rdsDrv.StringCmd {`
432	`return i.GetProxy().SPop(ctx, key)`
433	`}`

func instance.SPopN

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

434	`func (i instance) SPopN(ctx context.Context, key string, count int64) rdsDrv.StringSliceCmd {`
435	`return i.GetProxy().SPopN(ctx, key, count)`
436	`}`

func instance.SRandMember

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

437	`func (i instance) SRandMember(ctx context.Context, key string) rdsDrv.StringCmd {`
438	`return i.GetProxy().SRandMember(ctx, key)`
439	`}`

func instance.SRandMemberN

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

440	`func (i instance) SRandMemberN(ctx context.Context, key string, count int64) rdsDrv.StringSliceCmd {`
441	`return i.GetProxy().SRandMemberN(ctx, key, count)`
442	`}`

func instance.SRem

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

443	`func (i instance) SRem(ctx context.Context, key string, members ...any) rdsDrv.IntCmd {`
444	`return i.GetProxy().SRem(ctx, key, members...)`
445	`}`

func instance.SUnion

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

446	`func (i instance) SUnion(ctx context.Context, keys ...string) rdsDrv.StringSliceCmd {`
447	`return i.GetProxy().SUnion(ctx, keys...)`
448	`}`

func instance.SUnionStore

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

449	`func (i instance) SUnionStore(ctx context.Context, destination string, keys ...string) rdsDrv.IntCmd {`
450	`return i.GetProxy().SUnionStore(ctx, destination, keys...)`
451	`}`

func instance.Echo

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

37	`func (i instance) Echo(ctx context.Context, message any) rdsDrv.StringCmd {`
38	`return i.GetProxy().Echo(ctx, message)`
39	`}`

func instance.XDel

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

455	`func (i instance) XDel(ctx context.Context, stream string, ids ...string) rdsDrv.IntCmd {`
456	`return i.GetProxy().XDel(ctx, stream, ids...)`
457	`}`

func instance.XLen

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

458	`func (i instance) XLen(ctx context.Context, stream string) rdsDrv.IntCmd {`
459	`return i.GetProxy().XLen(ctx, stream)`
460	`}`

func instance.XRange

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

461	`func (i instance) XRange(ctx context.Context, stream, start, stop string) rdsDrv.XMessageSliceCmd {`
462	`return i.GetProxy().XRange(ctx, stream, start, stop)`
463	`}`

func instance.XRangeN

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

464	`func (i instance) XRangeN(ctx context.Context, stream, start, stop string, count int64) rdsDrv.XMessageSliceCmd {`
465	`return i.GetProxy().XRangeN(ctx, stream, start, stop, count)`
466	`}`

func instance.XRevRange

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

467	`func (i instance) XRevRange(ctx context.Context, stream string, start, stop string) rdsDrv.XMessageSliceCmd {`
468	`return i.GetProxy().XRevRange(ctx, stream, start, stop)`
469	`}`

func instance.XRevRangeN

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

470	`func (i *instance) XRevRangeN(ctx context.Context, stream string,`
471	`start, stop string, count int64) *rdsDrv.XMessageSliceCmd {`
472	`return i.GetProxy().XRevRangeN(ctx, stream, start, stop, count)`
473	`}`

func instance.XRead

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

474	`func (i instance) XRead(ctx context.Context, a rdsDrv.XReadArgs) *rdsDrv.XStreamSliceCmd {`
475	`return i.GetProxy().XRead(ctx, a)`
476	`}`

func instance.XReadStreams

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

477	`func (i instance) XReadStreams(ctx context.Context, streams ...string) rdsDrv.XStreamSliceCmd {`
478	`return i.GetProxy().XReadStreams(ctx, streams...)`
479	`}`

func instance.XGroupCreate

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

480	`func (i instance) XGroupCreate(ctx context.Context, stream, group, start string) rdsDrv.StatusCmd {`
481	`return i.GetProxy().XGroupCreate(ctx, stream, group, start)`
482	`}`

func instance.ClientGetName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

34	`func (i instance) ClientGetName(ctx context.Context) rdsDrv.StringCmd {`
35	`return i.GetProxy().ClientGetName(ctx)`
36	`}`

func instance.XGroupSetID

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

486	`func (i instance) XGroupSetID(ctx context.Context, stream, group, start string) rdsDrv.StatusCmd {`
487	`return i.GetProxy().XGroupSetID(ctx, stream, group, start)`
488	`}`

func instance.XGroupDestroy

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

489	`func (i instance) XGroupDestroy(ctx context.Context, stream, group string) rdsDrv.IntCmd {`
490	`return i.GetProxy().XGroupDestroy(ctx, stream, group)`
491	`}`

func instance.XGroupCreateConsumer

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

492	`func (i instance) XGroupCreateConsumer(ctx context.Context, stream, group, consumer string) rdsDrv.IntCmd {`
493	`return i.GetProxy().XGroupCreateConsumer(ctx, stream, group, consumer)`
494	`}`

func instance.XGroupDelConsumer

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

495	`func (i instance) XGroupDelConsumer(ctx context.Context, stream, group, consumer string) rdsDrv.IntCmd {`
496	`return i.GetProxy().XGroupDelConsumer(ctx, stream, group, consumer)`
497	`}`

func instance.CommandGetKeysAndFlags

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

31	`func (i instance) CommandGetKeysAndFlags(ctx context.Context, commands ...any) rdsDrv.KeyFlagsCmd {`
32	`return i.GetProxy().CommandGetKeysAndFlags(ctx, commands...)`
33	`}`

func instance.LTrim

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

370	`func (i instance) LTrim(ctx context.Context, key string, start, stop int64) rdsDrv.StatusCmd {`
371	`return i.GetProxy().LTrim(ctx, key, start, stop)`
372	`}`

func instance.XPending

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

504	`func (i instance) XPending(ctx context.Context, stream, group string) rdsDrv.XPendingCmd {`
505	`return i.GetProxy().XPending(ctx, stream, group)`
506	`}`

func instance.CommandGetKeys

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

28	`func (i instance) CommandGetKeys(ctx context.Context, commands ...any) rdsDrv.StringSliceCmd {`
29	`return i.GetProxy().CommandGetKeys(ctx, commands...)`
30	`}`

func instance.CommandList

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

25	`func (i instance) CommandList(ctx context.Context, filter rdsDrv.FilterBy) *rdsDrv.StringSliceCmd {`
26	`return i.GetProxy().CommandList(ctx, filter)`
27	`}`

func instance.XClaimJustID

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

513	`func (i instance) XClaimJustID(ctx context.Context, a rdsDrv.XClaimArgs) *rdsDrv.StringSliceCmd {`
514	`return i.GetProxy().XClaimJustID(ctx, a)`
515	`}`

func instance.XAutoClaim

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

516	`func (i instance) XAutoClaim(ctx context.Context, a rdsDrv.XAutoClaimArgs) *rdsDrv.XAutoClaimCmd {`
517	`return i.GetProxy().XAutoClaim(ctx, a)`
518	`}`

func instance.XAutoClaimJustID

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

519	`func (i instance) XAutoClaimJustID(ctx context.Context, a rdsDrv.XAutoClaimArgs) *rdsDrv.XAutoClaimJustIDCmd {`
520	`return i.GetProxy().XAutoClaimJustID(ctx, a)`
521	`}`

func instance.XTrimMaxLen

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

522	`func (i instance) XTrimMaxLen(ctx context.Context, key string, maxLen int64) rdsDrv.IntCmd {`
523	`return i.GetProxy().XTrimMaxLen(ctx, key, maxLen)`
524	`}`

func instance.XTrimMaxLenApprox

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

525	`func (i instance) XTrimMaxLenApprox(ctx context.Context, key string, maxLen, limit int64) rdsDrv.IntCmd {`
526	`return i.GetProxy().XTrimMaxLenApprox(ctx, key, maxLen, limit)`
527	`}`

func instance.XTrimMinID

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

528	`func (i instance) XTrimMinID(ctx context.Context, key string, minID string) rdsDrv.IntCmd {`
529	`return i.GetProxy().XTrimMinID(ctx, key, minID)`
530	`}`

func instance.XTrimMinIDApprox

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

531	`func (i instance) XTrimMinIDApprox(ctx context.Context, key string, minID string, limit int64) rdsDrv.IntCmd {`
532	`return i.GetProxy().XTrimMinIDApprox(ctx, key, minID, limit)`
533	`}`

func instance.XInfoGroups

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

534	`func (i instance) XInfoGroups(ctx context.Context, key string) rdsDrv.XInfoGroupsCmd {`
535	`return i.GetProxy().XInfoGroups(ctx, key)`
536	`}`

func instance.XInfoStream

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

537	`func (i instance) XInfoStream(ctx context.Context, key string) rdsDrv.XInfoStreamCmd {`
538	`return i.GetProxy().XInfoStream(ctx, key)`
539	`}`

func instance.XInfoStreamFull

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

540	`func (i instance) XInfoStreamFull(ctx context.Context, key string, count int) rdsDrv.XInfoStreamFullCmd {`
541	`return i.GetProxy().XInfoStreamFull(ctx, key, count)`
542	`}`

func instance.XInfoConsumers

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

543	`func (i instance) XInfoConsumers(ctx context.Context, key string, group string) rdsDrv.XInfoConsumersCmd {`
544	`return i.GetProxy().XInfoConsumers(ctx, key, group)`
545	`}`

func instance.BZPopMax

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

546	`func (i instance) BZPopMax(ctx context.Context, timeout time.Duration, keys ...string) rdsDrv.ZWithKeyCmd {`
547	`return i.GetProxy().BZPopMax(ctx, timeout, keys...)`
548	`}`

func instance.BZPopMin

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

549	`func (i instance) BZPopMin(ctx context.Context, timeout time.Duration, keys ...string) rdsDrv.ZWithKeyCmd {`
550	`return i.GetProxy().BZPopMin(ctx, timeout, keys...)`
551	`}`

func instance.BZMPop

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

552	`func (i *instance) BZMPop(ctx context.Context, timeout time.Duration, order string,`
553	`count int64, keys ...string) *rdsDrv.ZSliceWithKeyCmd {`
554	`return i.GetProxy().BZMPop(ctx, timeout, order, count, keys...)`
555	`}`

func instance.Command

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

22	`func (i instance) Command(ctx context.Context) rdsDrv.CommandsInfoCmd {`
23	`return i.GetProxy().Command(ctx)`
24	`}`

func instance.ZAddLT

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

559	`func (i instance) ZAddLT(ctx context.Context, key string, members ...rdsDrv.Z) rdsDrv.IntCmd {`
560	`return i.GetProxy().ZAddLT(ctx, key, members...)`
561	`}`

func instance.ZAddGT

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

562	`func (i instance) ZAddGT(ctx context.Context, key string, members ...rdsDrv.Z) rdsDrv.IntCmd {`
563	`return i.GetProxy().ZAddGT(ctx, key, members...)`
564	`}`

func instance.ZAddNX

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

565	`func (i instance) ZAddNX(ctx context.Context, key string, members ...rdsDrv.Z) rdsDrv.IntCmd {`
566	`return i.GetProxy().ZAddNX(ctx, key, members...)`
567	`}`

func instance.ZAddXX

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

568	`func (i instance) ZAddXX(ctx context.Context, key string, members ...rdsDrv.Z) rdsDrv.IntCmd {`
569	`return i.GetProxy().ZAddXX(ctx, key, members...)`
570	`}`

func instance.ZAddArgs

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

571	`func (i instance) ZAddArgs(ctx context.Context, key string, args rdsDrv.ZAddArgs) rdsDrv.IntCmd {`
572	`return i.GetProxy().ZAddArgs(ctx, key, args)`
573	`}`

func instance.ZAddArgsIncr

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

574	`func (i instance) ZAddArgsIncr(ctx context.Context, key string, args rdsDrv.ZAddArgs) rdsDrv.FloatCmd {`
575	`return i.GetProxy().ZAddArgsIncr(ctx, key, args)`
576	`}`

func instance.ZCard

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

577	`func (i instance) ZCard(ctx context.Context, key string) rdsDrv.IntCmd {`
578	`return i.GetProxy().ZCard(ctx, key)`
579	`}`

func instance.ZCount

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

580	`func (i instance) ZCount(ctx context.Context, key, min, max string) rdsDrv.IntCmd {`
581	`return i.GetProxy().ZCount(ctx, key, min, max)`
582	`}`

func instance.ZLexCount

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

583	`func (i instance) ZLexCount(ctx context.Context, key, min, max string) rdsDrv.IntCmd {`
584	`return i.GetProxy().ZLexCount(ctx, key, min, max)`
585	`}`

func instance.ZIncrBy

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

586	`func (i instance) ZIncrBy(ctx context.Context, key string, increment float64, member string) rdsDrv.FloatCmd {`
587	`return i.GetProxy().ZIncrBy(ctx, key, increment, member)`
588	`}`

func instance.ZInter

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

589	`func (i instance) ZInter(ctx context.Context, store rdsDrv.ZStore) *rdsDrv.StringSliceCmd {`
590	`return i.GetProxy().ZInter(ctx, store)`
591	`}`

func instance.ZInterWithScores

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

592	`func (i instance) ZInterWithScores(ctx context.Context, store rdsDrv.ZStore) *rdsDrv.ZSliceCmd {`
593	`return i.GetProxy().ZInterWithScores(ctx, store)`
594	`}`

func instance.ZInterCard

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

595	`func (i instance) ZInterCard(ctx context.Context, limit int64, keys ...string) rdsDrv.IntCmd {`
596	`return i.GetProxy().ZInterCard(ctx, limit, keys...)`
597	`}`

func instance.ZInterStore

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

598	`func (i instance) ZInterStore(ctx context.Context, destination string, store rdsDrv.ZStore) *rdsDrv.IntCmd {`
599	`return i.GetProxy().ZInterStore(ctx, destination, store)`
600	`}`

func instance.ZMPop

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

601	`func (i instance) ZMPop(ctx context.Context, order string, count int64, keys ...string) rdsDrv.ZSliceWithKeyCmd {`
602	`return i.GetProxy().ZMPop(ctx, order, count, keys...)`
603	`}`

func instance.ZMScore

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

604	`func (i instance) ZMScore(ctx context.Context, key string, members ...string) rdsDrv.FloatSliceCmd {`
605	`return i.GetProxy().ZMScore(ctx, key, members...)`
606	`}`

func instance.ZPopMax

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

607	`func (i instance) ZPopMax(ctx context.Context, key string, count ...int64) rdsDrv.ZSliceCmd {`
608	`return i.GetProxy().ZPopMax(ctx, key, count...)`
609	`}`

func instance.ZPopMin

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

610	`func (i instance) ZPopMin(ctx context.Context, key string, count ...int64) rdsDrv.ZSliceCmd {`
611	`return i.GetProxy().ZPopMin(ctx, key, count...)`
612	`}`

func instance.ZRange

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

613	`func (i instance) ZRange(ctx context.Context, key string, start, stop int64) rdsDrv.StringSliceCmd {`
614	`return i.GetProxy().ZRange(ctx, key, start, stop)`
615	`}`

func instance.ZRangeWithScores

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

616	`func (i instance) ZRangeWithScores(ctx context.Context, key string, start, stop int64) rdsDrv.ZSliceCmd {`
617	`return i.GetProxy().ZRangeWithScores(ctx, key, start, stop)`
618	`}`

func instance.ZRangeByScore

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

619	`func (i instance) ZRangeByScore(ctx context.Context, key string, opt rdsDrv.ZRangeBy) *rdsDrv.StringSliceCmd {`
620	`return i.GetProxy().ZRangeByScore(ctx, key, opt)`
621	`}`

func instance.ZRangeByLex

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

622	`func (i instance) ZRangeByLex(ctx context.Context, key string, opt rdsDrv.ZRangeBy) *rdsDrv.StringSliceCmd {`
623	`return i.GetProxy().ZRangeByLex(ctx, key, opt)`
624	`}`

func instance.ZRangeByScoreWithScores

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

625	`func (i instance) ZRangeByScoreWithScores(ctx context.Context, key string, opt rdsDrv.ZRangeBy) *rdsDrv.ZSliceCmd {`
626	`return i.GetProxy().ZRangeByScoreWithScores(ctx, key, opt)`
627	`}`

func instance.ZRangeArgs

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

628	`func (i instance) ZRangeArgs(ctx context.Context, z rdsDrv.ZRangeArgs) rdsDrv.StringSliceCmd {`
629	`return i.GetProxy().ZRangeArgs(ctx, z)`
630	`}`

func instance.ZRangeArgsWithScores

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

631	`func (i instance) ZRangeArgsWithScores(ctx context.Context, z rdsDrv.ZRangeArgs) rdsDrv.ZSliceCmd {`
632	`return i.GetProxy().ZRangeArgsWithScores(ctx, z)`
633	`}`

func instance.ZRangeStore

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

634	`func (i instance) ZRangeStore(ctx context.Context, dst string, z rdsDrv.ZRangeArgs) rdsDrv.IntCmd {`
635	`return i.GetProxy().ZRangeStore(ctx, dst, z)`
636	`}`

func instance.ZRank

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

637	`func (i instance) ZRank(ctx context.Context, key, member string) rdsDrv.IntCmd {`
638	`return i.GetProxy().ZRank(ctx, key, member)`
639	`}`

func instance.ZRankWithScore

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

640	`func (i instance) ZRankWithScore(ctx context.Context, key, member string) rdsDrv.RankWithScoreCmd {`
641	`return i.GetProxy().ZRankWithScore(ctx, key, member)`
642	`}`

func instance.TxPipeline

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

19	`func (i *instance) TxPipeline() rdsDrv.Pipeliner {`
20	`return i.GetProxy().TxPipeline()`
21	`}`

func instance.ZRemRangeByRank

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

647	`func (i instance) ZRemRangeByRank(ctx context.Context, key string, start, stop int64) rdsDrv.IntCmd {`
648	`return i.GetProxy().ZRemRangeByRank(ctx, key, start, stop)`
649	`}`

func instance.ZRemRangeByScore

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

650	`func (i instance) ZRemRangeByScore(ctx context.Context, key, min, max string) rdsDrv.IntCmd {`
651	`return i.GetProxy().ZRemRangeByScore(ctx, key, min, max)`
652	`}`

func instance.ZRemRangeByLex

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

653	`func (i instance) ZRemRangeByLex(ctx context.Context, key, min, max string) rdsDrv.IntCmd {`
654	`return i.GetProxy().ZRemRangeByLex(ctx, key, min, max)`
655	`}`

func instance.ZRevRange

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

656	`func (i instance) ZRevRange(ctx context.Context, key string, start, stop int64) rdsDrv.StringSliceCmd {`
657	`return i.GetProxy().ZRevRange(ctx, key, start, stop)`
658	`}`

func instance.ZRevRangeWithScores

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

659	`func (i instance) ZRevRangeWithScores(ctx context.Context, key string, start, stop int64) rdsDrv.ZSliceCmd {`
660	`return i.GetProxy().ZRevRangeWithScores(ctx, key, start, stop)`
661	`}`

func instance.ZRevRangeByScore

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

662	`func (i instance) ZRevRangeByScore(ctx context.Context, key string, opt rdsDrv.ZRangeBy) *rdsDrv.StringSliceCmd {`
663	`return i.GetProxy().ZRevRangeByScore(ctx, key, opt)`
664	`}`

func instance.ZRevRangeByLex

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

665	`func (i instance) ZRevRangeByLex(ctx context.Context, key string, opt rdsDrv.ZRangeBy) *rdsDrv.StringSliceCmd {`
666	`return i.GetProxy().ZRevRangeByLex(ctx, key, opt)`
667	`}`

func instance.ZRevRangeByScoreWithScores

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

668	`func (i instance) ZRevRangeByScoreWithScores(ctx context.Context, key string, opt rdsDrv.ZRangeBy) *rdsDrv.ZSliceCmd {`
669	`return i.GetProxy().ZRevRangeByScoreWithScores(ctx, key, opt)`
670	`}`

func instance.ZRevRank

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

671	`func (i instance) ZRevRank(ctx context.Context, key, member string) rdsDrv.IntCmd {`
672	`return i.GetProxy().ZRevRank(ctx, key, member)`
673	`}`

func instance.ZRevRankWithScore

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

674	`func (i instance) ZRevRankWithScore(ctx context.Context, key, member string) rdsDrv.RankWithScoreCmd {`
675	`return i.GetProxy().ZRevRankWithScore(ctx, key, member)`
676	`}`

func instance.ZScore

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

677	`func (i instance) ZScore(ctx context.Context, key, member string) rdsDrv.FloatCmd {`
678	`return i.GetProxy().ZScore(ctx, key, member)`
679	`}`

func instance.ZUnionStore

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

680	`func (i instance) ZUnionStore(ctx context.Context, dest string, store rdsDrv.ZStore) *rdsDrv.IntCmd {`
681	`return i.GetProxy().ZUnionStore(ctx, dest, store)`
682	`}`

func instance.ZRandMember

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

683	`func (i instance) ZRandMember(ctx context.Context, key string, count int) rdsDrv.StringSliceCmd {`
684	`return i.GetProxy().ZRandMember(ctx, key, count)`
685	`}`

func instance.ZRandMemberWithScores

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

686	`func (i instance) ZRandMemberWithScores(ctx context.Context, key string, count int) rdsDrv.ZSliceCmd {`
687	`return i.GetProxy().ZRandMemberWithScores(ctx, key, count)`
688	`}`

func instance.ZUnion

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

689	`func (i instance) ZUnion(ctx context.Context, store rdsDrv.ZStore) rdsDrv.StringSliceCmd {`
690	`return i.GetProxy().ZUnion(ctx, store)`
691	`}`

func instance.ZUnionWithScores

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

692	`func (i instance) ZUnionWithScores(ctx context.Context, store rdsDrv.ZStore) rdsDrv.ZSliceCmd {`
693	`return i.GetProxy().ZUnionWithScores(ctx, store)`
694	`}`

func instance.ZDiff

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

695	`func (i instance) ZDiff(ctx context.Context, keys ...string) rdsDrv.StringSliceCmd {`
696	`return i.GetProxy().ZDiff(ctx, keys...)`
697	`}`

func instance.ZDiffWithScores

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

698	`func (i instance) ZDiffWithScores(ctx context.Context, keys ...string) rdsDrv.ZSliceCmd {`
699	`return i.GetProxy().ZDiffWithScores(ctx, keys...)`
700	`}`

func instance.ZDiffStore

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

701	`func (i instance) ZDiffStore(ctx context.Context, destination string, keys ...string) rdsDrv.IntCmd {`
702	`return i.GetProxy().ZDiffStore(ctx, destination, keys...)`
703	`}`

func instance.PFAdd

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

704	`func (i instance) PFAdd(ctx context.Context, key string, els ...any) rdsDrv.IntCmd {`
705	`return i.GetProxy().PFAdd(ctx, key, els...)`
706	`}`

func instance.PFCount

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

707	`func (i instance) PFCount(ctx context.Context, keys ...string) rdsDrv.IntCmd {`
708	`return i.GetProxy().PFCount(ctx, keys...)`
709	`}`

func instance.PFMerge

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

710	`func (i instance) PFMerge(ctx context.Context, dest string, keys ...string) rdsDrv.StatusCmd {`
711	`return i.GetProxy().PFMerge(ctx, dest, keys...)`
712	`}`

func instance.BgRewriteAOF

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

713	`func (i instance) BgRewriteAOF(ctx context.Context) rdsDrv.StatusCmd {`
714	`return i.GetProxy().BgRewriteAOF(ctx)`
715	`}`

func instance.BgSave

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

716	`func (i instance) BgSave(ctx context.Context) rdsDrv.StatusCmd {`
717	`return i.GetProxy().BgSave(ctx)`
718	`}`

func instance.ClientKill

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

719	`func (i instance) ClientKill(ctx context.Context, ipPort string) rdsDrv.StatusCmd {`
720	`return i.GetProxy().ClientKill(ctx, ipPort)`
721	`}`

func instance.ClientKillByFilter

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

722	`func (i instance) ClientKillByFilter(ctx context.Context, keys ...string) rdsDrv.IntCmd {`
723	`return i.GetProxy().ClientKillByFilter(ctx, keys...)`
724	`}`

func instance.ClientList

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

725	`func (i instance) ClientList(ctx context.Context) rdsDrv.StringCmd {`
726	`return i.GetProxy().ClientList(ctx)`
727	`}`

func instance.ClientPause

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

728	`func (i instance) ClientPause(ctx context.Context, dur time.Duration) rdsDrv.BoolCmd {`
729	`return i.GetProxy().ClientPause(ctx, dur)`
730	`}`

func instance.ClientUnpause

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

731	`func (i instance) ClientUnpause(ctx context.Context) rdsDrv.BoolCmd {`
732	`return i.GetProxy().ClientUnpause(ctx)`
733	`}`

func instance.ClientID

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

734	`func (i instance) ClientID(ctx context.Context) rdsDrv.IntCmd {`
735	`return i.GetProxy().ClientID(ctx)`
736	`}`

func instance.ClientUnblock

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

737	`func (i instance) ClientUnblock(ctx context.Context, id int64) rdsDrv.IntCmd {`
738	`return i.GetProxy().ClientUnblock(ctx, id)`
739	`}`

func instance.ClientUnblockWithError

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

740	`func (i instance) ClientUnblockWithError(ctx context.Context, id int64) rdsDrv.IntCmd {`
741	`return i.GetProxy().ClientUnblockWithError(ctx, id)`
742	`}`

func instance.ClientInfo

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

743	`func (i instance) ClientInfo(ctx context.Context) rdsDrv.ClientInfoCmd {`
744	`return i.GetProxy().ClientInfo(ctx)`
745	`}`

func instance.ConfigGet

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

746	`func (i instance) ConfigGet(ctx context.Context, parameter string) rdsDrv.MapStringStringCmd {`
747	`return i.GetProxy().ConfigGet(ctx, parameter)`
748	`}`

func instance.ConfigResetStat

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

749	`func (i instance) ConfigResetStat(ctx context.Context) rdsDrv.StatusCmd {`
750	`return i.GetProxy().ConfigResetStat(ctx)`
751	`}`

func instance.ConfigSet

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

752	`func (i instance) ConfigSet(ctx context.Context, parameter, value string) rdsDrv.StatusCmd {`
753	`return i.GetProxy().ConfigSet(ctx, parameter, value)`
754	`}`

func instance.ConfigRewrite

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

755	`func (i instance) ConfigRewrite(ctx context.Context) rdsDrv.StatusCmd {`
756	`return i.GetProxy().ConfigRewrite(ctx)`
757	`}`

func instance.DBSize

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

758	`func (i instance) DBSize(ctx context.Context) rdsDrv.IntCmd {`
759	`return i.GetProxy().DBSize(ctx)`
760	`}`

func instance.FlushAll

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

761	`func (i instance) FlushAll(ctx context.Context) rdsDrv.StatusCmd {`
762	`return i.GetProxy().FlushAll(ctx)`
763	`}`

func instance.FlushAllAsync

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

764	`func (i instance) FlushAllAsync(ctx context.Context) rdsDrv.StatusCmd {`
765	`return i.GetProxy().FlushAllAsync(ctx)`
766	`}`

func instance.FlushDB

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

767	`func (i instance) FlushDB(ctx context.Context) rdsDrv.StatusCmd {`
768	`return i.GetProxy().FlushDB(ctx)`
769	`}`

func instance.FlushDBAsync

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

770	`func (i instance) FlushDBAsync(ctx context.Context) rdsDrv.StatusCmd {`
771	`return i.GetProxy().FlushDBAsync(ctx)`
772	`}`

func instance.Info

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

773	`func (i instance) Info(ctx context.Context, section ...string) rdsDrv.StringCmd {`
774	`return i.GetProxy().Info(ctx, section...)`
775	`}`

func instance.LastSave

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

776	`func (i instance) LastSave(ctx context.Context) rdsDrv.IntCmd {`
777	`return i.GetProxy().LastSave(ctx)`
778	`}`

func instance.Save

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

779	`func (i instance) Save(ctx context.Context) rdsDrv.StatusCmd {`
780	`return i.GetProxy().Save(ctx)`
781	`}`

func instance.Shutdown

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

782	`func (i instance) Shutdown(ctx context.Context) rdsDrv.StatusCmd {`
783	`return i.GetProxy().Shutdown(ctx)`
784	`}`

func instance.ShutdownSave

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

785	`func (i instance) ShutdownSave(ctx context.Context) rdsDrv.StatusCmd {`
786	`return i.GetProxy().ShutdownSave(ctx)`
787	`}`

func instance.ShutdownNoSave

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

788	`func (i instance) ShutdownNoSave(ctx context.Context) rdsDrv.StatusCmd {`
789	`return i.GetProxy().ShutdownNoSave(ctx)`
790	`}`

func instance.SlaveOf

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

791	`func (i instance) SlaveOf(ctx context.Context, host, port string) rdsDrv.StatusCmd {`
792	`return i.GetProxy().SlaveOf(ctx, host, port)`
793	`}`

func instance.SlowLogGet

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

794	`func (i instance) SlowLogGet(ctx context.Context, num int64) rdsDrv.SlowLogCmd {`
795	`return i.GetProxy().SlowLogGet(ctx, num)`
796	`}`

func instance.Time

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

797	`func (i instance) Time(ctx context.Context) rdsDrv.TimeCmd { return i.GetProxy().Time(ctx) }`

func instance.DebugObject

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

798	`func (i instance) DebugObject(ctx context.Context, key string) rdsDrv.StringCmd {`
799	`return i.GetProxy().DebugObject(ctx, key)`
800	`}`

func instance.ReadOnly

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

801	`func (i instance) ReadOnly(ctx context.Context) rdsDrv.StatusCmd { return i.GetProxy().ReadOnly(ctx) }`

func instance.ReadWrite

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

802	`func (i instance) ReadWrite(ctx context.Context) rdsDrv.StatusCmd {`
803	`return i.GetProxy().ReadWrite(ctx)`
804	`}`

func instance.MemoryUsage

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

805	`func (i instance) MemoryUsage(ctx context.Context, key string, samples ...int) rdsDrv.IntCmd {`
806	`return i.GetProxy().MemoryUsage(ctx, key, samples...)`
807	`}`

func instance.TxPipelined

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

16	`func (i *instance) TxPipelined(ctx context.Context, fn func(rdsDrv.Pipeliner) error) ([]rdsDrv.Cmder, error) {`
17	`return i.GetProxy().TxPipelined(ctx, fn)`
18	`}`

func instance.Pipelined

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

13	`func (i *instance) Pipelined(ctx context.Context, fn func(rdsDrv.Pipeliner) error) ([]rdsDrv.Cmder, error) {`
14	`return i.GetProxy().Pipelined(ctx, fn)`
15	`}`

func instance.EvalRO

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

814	`func (i instance) EvalRO(ctx context.Context, script string, keys []string, args ...any) rdsDrv.Cmd {`
815	`return i.GetProxy().EvalRO(ctx, script, keys, args...)`
816	`}`

func instance.EvalShaRO

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

817	`func (i instance) EvalShaRO(ctx context.Context, sha1 string, keys []string, args ...any) rdsDrv.Cmd {`
818	`return i.GetProxy().EvalShaRO(ctx, sha1, keys, args...)`
819	`}`

func instance.ScriptExists

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

820	`func (i instance) ScriptExists(ctx context.Context, hashes ...string) rdsDrv.BoolSliceCmd {`
821	`return i.GetProxy().ScriptExists(ctx, hashes...)`
822	`}`

func instance.ScriptFlush

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

823	`func (i instance) ScriptFlush(ctx context.Context) rdsDrv.StatusCmd {`
824	`return i.GetProxy().ScriptFlush(ctx)`
825	`}`

func instance.ScriptKill

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

826	`func (i instance) ScriptKill(ctx context.Context) rdsDrv.StatusCmd {`
827	`return i.GetProxy().ScriptKill(ctx)`
828	`}`

func instance.ScriptLoad

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

829	`func (i instance) ScriptLoad(ctx context.Context, script string) rdsDrv.StringCmd {`
830	`return i.GetProxy().ScriptLoad(ctx, script)`
831	`}`

func instance.FunctionLoad

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

832	`func (i instance) FunctionLoad(ctx context.Context, code string) rdsDrv.StringCmd {`
833	`return i.GetProxy().FunctionLoad(ctx, code)`
834	`}`

func instance.FunctionLoadReplace

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

835	`func (i instance) FunctionLoadReplace(ctx context.Context, code string) rdsDrv.StringCmd {`
836	`return i.GetProxy().FunctionLoadReplace(ctx, code)`
837	`}`

func instance.FunctionDelete

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

838	`func (i instance) FunctionDelete(ctx context.Context, libName string) rdsDrv.StringCmd {`
839	`return i.GetProxy().FunctionDelete(ctx, libName)`
840	`}`

func instance.FunctionFlush

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

841	`func (i instance) FunctionFlush(ctx context.Context) rdsDrv.StringCmd {`
842	`return i.GetProxy().FunctionFlush(ctx)`
843	`}`

func instance.FunctionKill

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

844	`func (i instance) FunctionKill(ctx context.Context) rdsDrv.StringCmd {`
845	`return i.GetProxy().FunctionKill(ctx)`
846	`}`

func instance.FunctionFlushAsync

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

847	`func (i instance) FunctionFlushAsync(ctx context.Context) rdsDrv.StringCmd {`
848	`return i.GetProxy().FunctionFlushAsync(ctx)`
849	`}`

func instance.FunctionList

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

850	`func (i instance) FunctionList(ctx context.Context, q rdsDrv.FunctionListQuery) rdsDrv.FunctionListCmd {`
851	`return i.GetProxy().FunctionList(ctx, q)`
852	`}`

func instance.FunctionDump

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

853	`func (i instance) FunctionDump(ctx context.Context) rdsDrv.StringCmd {`
854	`return i.GetProxy().FunctionDump(ctx)`
855	`}`

func instance.FunctionRestore

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

856	`func (i instance) FunctionRestore(ctx context.Context, libDump string) rdsDrv.StringCmd {`
857	`return i.GetProxy().FunctionRestore(ctx, libDump)`
858	`}`

func instance.FunctionStats

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

859	`func (i instance) FunctionStats(ctx context.Context) rdsDrv.FunctionStatsCmd {`
860	`return i.GetProxy().FunctionStats(ctx)`
861	`}`

func instance.FCall

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

862	`func (i instance) FCall(ctx context.Context, function string, keys []string, args ...any) rdsDrv.Cmd {`
863	`return i.GetProxy().FCall(ctx, function, keys, args...)`
864	`}`

func instance.FCallRo

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

865	`func (i instance) FCallRo(ctx context.Context, function string, keys []string, args ...any) rdsDrv.Cmd {`
866	`return i.GetProxy().FCallRo(ctx, function, keys, args...)`
867	`}`

func instance.FCallRO

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

868	`func (i instance) FCallRO(ctx context.Context, function string, keys []string, args ...interface{}) rdsDrv.Cmd {`
869	`return i.GetProxy().FCallRO(ctx, function, keys, args...)`
870	`}`

func instance.Publish

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

871	`func (i instance) Publish(ctx context.Context, channel string, message any) rdsDrv.IntCmd {`
872	`return i.GetProxy().Publish(ctx, channel, message)`
873	`}`

func instance.SPublish

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

874	`func (i instance) SPublish(ctx context.Context, channel string, message any) rdsDrv.IntCmd {`
875	`return i.GetProxy().SPublish(ctx, channel, message)`
876	`}`

func instance.PubSubChannels

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

877	`func (i instance) PubSubChannels(ctx context.Context, pattern string) rdsDrv.StringSliceCmd {`
878	`return i.GetProxy().PubSubChannels(ctx, pattern)`
879	`}`

func instance.PubSubNumSub

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

880	`func (i instance) PubSubNumSub(ctx context.Context, channels ...string) rdsDrv.MapStringIntCmd {`
881	`return i.GetProxy().PubSubNumSub(ctx, channels...)`
882	`}`

func instance.PubSubNumPat

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

883	`func (i instance) PubSubNumPat(ctx context.Context) rdsDrv.IntCmd {`
884	`return i.GetProxy().PubSubNumPat(ctx)`
885	`}`

func instance.PubSubShardChannels

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

886	`func (i instance) PubSubShardChannels(ctx context.Context, pattern string) rdsDrv.StringSliceCmd {`
887	`return i.GetProxy().PubSubShardChannels(ctx, pattern)`
888	`}`

func instance.PubSubShardNumSub

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

889	`func (i instance) PubSubShardNumSub(ctx context.Context, channels ...string) rdsDrv.MapStringIntCmd {`
890	`return i.GetProxy().PubSubShardNumSub(ctx, channels...)`
891	`}`

func instance.ClusterMyShardID

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

892	`func (i instance) ClusterMyShardID(ctx context.Context) rdsDrv.StringCmd {`
893	`return i.GetProxy().ClusterMyShardID(ctx)`
894	`}`

func instance.ClusterSlots

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

895	`func (i instance) ClusterSlots(ctx context.Context) rdsDrv.ClusterSlotsCmd {`
896	`return i.GetProxy().ClusterSlots(ctx)`
897	`}`

func instance.ClusterShards

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

898	`func (i instance) ClusterShards(ctx context.Context) rdsDrv.ClusterShardsCmd {`
899	`return i.GetProxy().ClusterShards(ctx)`
900	`}`

func instance.ClusterLinks

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

901	`func (i instance) ClusterLinks(ctx context.Context) rdsDrv.ClusterLinksCmd {`
902	`return i.GetProxy().ClusterLinks(ctx)`
903	`}`

func instance.ClusterNodes

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

904	`func (i instance) ClusterNodes(ctx context.Context) rdsDrv.StringCmd {`
905	`return i.GetProxy().ClusterNodes(ctx)`
906	`}`

func instance.ClusterMeet

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

907	`func (i instance) ClusterMeet(ctx context.Context, host, port string) rdsDrv.StatusCmd {`
908	`return i.GetProxy().ClusterMeet(ctx, host, port)`
909	`}`

func instance.ClusterForget

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

910	`func (i instance) ClusterForget(ctx context.Context, nodeID string) rdsDrv.StatusCmd {`
911	`return i.GetProxy().ClusterForget(ctx, nodeID)`
912	`}`

func instance.ClusterReplicate

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

913	`func (i instance) ClusterReplicate(ctx context.Context, nodeID string) rdsDrv.StatusCmd {`
914	`return i.GetProxy().ClusterReplicate(ctx, nodeID)`
915	`}`

func instance.ClusterResetSoft

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

916	`func (i instance) ClusterResetSoft(ctx context.Context) rdsDrv.StatusCmd {`
917	`return i.GetProxy().ClusterResetSoft(ctx)`
918	`}`

func instance.ClusterResetHard

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

919	`func (i instance) ClusterResetHard(ctx context.Context) rdsDrv.StatusCmd {`
920	`return i.GetProxy().ClusterResetHard(ctx)`
921	`}`

func instance.ClusterInfo

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

922	`func (i instance) ClusterInfo(ctx context.Context) rdsDrv.StringCmd {`
923	`return i.GetProxy().ClusterInfo(ctx)`
924	`}`

func instance.ClusterKeySlot

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

925	`func (i instance) ClusterKeySlot(ctx context.Context, key string) rdsDrv.IntCmd {`
926	`return i.GetProxy().ClusterKeySlot(ctx, key)`
927	`}`

func instance.ClusterGetKeysInSlot

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

928	`func (i instance) ClusterGetKeysInSlot(ctx context.Context, slot int, count int) rdsDrv.StringSliceCmd {`
929	`return i.GetProxy().ClusterGetKeysInSlot(ctx, slot, count)`
930	`}`

func instance.ClusterCountFailureReports

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

931	`func (i instance) ClusterCountFailureReports(ctx context.Context, nodeID string) rdsDrv.IntCmd {`
932	`return i.GetProxy().ClusterCountFailureReports(ctx, nodeID)`
933	`}`

func instance.ClusterCountKeysInSlot

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

934	`func (i instance) ClusterCountKeysInSlot(ctx context.Context, slot int) rdsDrv.IntCmd {`
935	`return i.GetProxy().ClusterCountKeysInSlot(ctx, slot)`
936	`}`

func instance.ClusterDelSlots

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

937	`func (i instance) ClusterDelSlots(ctx context.Context, slots ...int) rdsDrv.StatusCmd {`
938	`return i.GetProxy().ClusterDelSlots(ctx, slots...)`
939	`}`

func instance.ClusterDelSlotsRange

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

940	`func (i instance) ClusterDelSlotsRange(ctx context.Context, min, max int) rdsDrv.StatusCmd {`
941	`return i.GetProxy().ClusterDelSlotsRange(ctx, min, max)`
942	`}`

func instance.ClusterSaveConfig

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

943	`func (i instance) ClusterSaveConfig(ctx context.Context) rdsDrv.StatusCmd {`
944	`return i.GetProxy().ClusterSaveConfig(ctx)`
945	`}`

func instance.ClusterSlaves

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

946	`func (i instance) ClusterSlaves(ctx context.Context, nodeID string) rdsDrv.StringSliceCmd {`
947	`return i.GetProxy().ClusterSlaves(ctx, nodeID)`
948	`}`

func instance.ClusterFailover

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

949	`func (i instance) ClusterFailover(ctx context.Context) rdsDrv.StatusCmd {`
950	`return i.GetProxy().ClusterFailover(ctx)`
951	`}`

func instance.ClusterAddSlots

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

952	`func (i instance) ClusterAddSlots(ctx context.Context, slots ...int) rdsDrv.StatusCmd {`
953	`return i.GetProxy().ClusterAddSlots(ctx, slots...)`
954	`}`

func instance.ClusterAddSlotsRange

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

955	`func (i instance) ClusterAddSlotsRange(ctx context.Context, min, max int) rdsDrv.StatusCmd {`
956	`return i.GetProxy().ClusterAddSlotsRange(ctx, min, max)`
957	`}`

func instance.GeoAdd

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

958	`func (i instance) GeoAdd(ctx context.Context, key string, geoLocation ...rdsDrv.GeoLocation) *rdsDrv.IntCmd {`
959	`return i.GetProxy().GeoAdd(ctx, key, geoLocation...)`
960	`}`

func instance.GeoPos

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

961	`func (i instance) GeoPos(ctx context.Context, key string, members ...string) rdsDrv.GeoPosCmd {`
962	`return i.GetProxy().GeoPos(ctx, key, members...)`
963	`}`

func instance.GeoRadius

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

964	`func (i *instance) GeoRadius(ctx context.Context, key string, longitude, latitude float64,`
965	`query rdsDrv.GeoRadiusQuery) rdsDrv.GeoLocationCmd {`
966	`return i.GetProxy().GeoRadius(ctx, key, longitude, latitude, query)`
967	`}`

func instance.GeoRadiusStore

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

968	`func (i *instance) GeoRadiusStore(ctx context.Context, key string, longitude, latitude float64,`
969	`query rdsDrv.GeoRadiusQuery) rdsDrv.IntCmd {`
970	`return i.GetProxy().GeoRadiusStore(ctx, key, longitude, latitude, query)`
971	`}`

func instance.GeoRadiusByMember

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

972	`func (i *instance) GeoRadiusByMember(ctx context.Context, key, member string,`
973	`query rdsDrv.GeoRadiusQuery) rdsDrv.GeoLocationCmd {`
974	`return i.GetProxy().GeoRadiusByMember(ctx, key, member, query)`
975	`}`

func instance.GeoRadiusByMemberStore

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

976	`func (i *instance) GeoRadiusByMemberStore(ctx context.Context, key, member string,`
977	`query rdsDrv.GeoRadiusQuery) rdsDrv.IntCmd {`
978	`return i.GetProxy().GeoRadiusByMemberStore(ctx, key, member, query)`
979	`}`

func instance.GeoSearch

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

980	`func (i instance) GeoSearch(ctx context.Context, key string, q rdsDrv.GeoSearchQuery) *rdsDrv.StringSliceCmd {`
981	`return i.GetProxy().GeoSearch(ctx, key, q)`
982	`}`

func instance.GeoSearchLocation

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

983	`func (i *instance) GeoSearchLocation(ctx context.Context, key string,`
984	`q rdsDrv.GeoSearchLocationQuery) rdsDrv.GeoSearchLocationCmd {`
985	`return i.GetProxy().GeoSearchLocation(ctx, key, q)`
986	`}`

func instance.GeoSearchStore

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

987	`func (i *instance) GeoSearchStore(ctx context.Context, key, store string,`
988	`q rdsDrv.GeoSearchStoreQuery) rdsDrv.IntCmd {`
989	`return i.GetProxy().GeoSearchStore(ctx, key, store, q)`
990	`}`

func instance.GeoDist

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

991	`func (i instance) GeoDist(ctx context.Context, key string, member1, member2, unit string) rdsDrv.FloatCmd {`
992	`return i.GetProxy().GeoDist(ctx, key, member1, member2, unit)`
993	`}`

func instance.GeoHash

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

994	`func (i instance) GeoHash(ctx context.Context, key string, members ...string) rdsDrv.StringSliceCmd {`
995	`return i.GetProxy().GeoHash(ctx, key, members...)`
996	`}`

func instance.ACLDryRun

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

997	`func (i instance) ACLDryRun(ctx context.Context, username string, command ...any) rdsDrv.StringCmd {`
998	`return i.GetProxy().ACLDryRun(ctx, username, command...)`
999	`}`

func instance.ModuleLoadex

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

1000	`func (i instance) ModuleLoadex(ctx context.Context, conf rdsDrv.ModuleLoadexConfig) *rdsDrv.StringCmd {`
1001	`return i.GetProxy().ModuleLoadex(ctx, conf)`
1002	`}`

func instance.AddHook

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

1003	`func (i *instance) AddHook(hk rdsDrv.Hook) {`
1004	`i.GetProxy().AddHook(hk)`
1005	`}`

func instance.Watch

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

1006	`func (i instance) Watch(ctx context.Context, fn func(rdsDrv.Tx) error, keys ...string) error {`
1007	`return i.GetProxy().Watch(ctx, fn, keys...)`
1008	`}`

func instance.Do

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

1009	`func (i instance) Do(ctx context.Context, args ...any) rdsDrv.Cmd {`
1010	`return i.GetProxy().Do(ctx, args...)`
1011	`}`

func instance.Process

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

1012	`func (i *instance) Process(ctx context.Context, cmd rdsDrv.Cmder) error {`
1013	`return i.GetProxy().Process(ctx, cmd)`
1014	`}`

func @83:22

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/construct.go:

83	`func() rdsDrv.UniversalClient { return Use(ctx, name, AppName(opt.AppName)) }`

func instance.PSubscribe

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

1018	`func (i instance) PSubscribe(ctx context.Context, channels ...string) rdsDrv.PubSub {`
1019	`return i.GetProxy().PSubscribe(ctx, channels...)`
1020	`}`

func instance.SSubscribe

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

1021	`func (i instance) SSubscribe(ctx context.Context, channels ...string) rdsDrv.PubSub {`
1022	`return i.GetProxy().SSubscribe(ctx, channels...)`
1023	`}`

func instance.Close

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

1024	`func (i *instance) Close() error {`
1025	`return i.GetProxy().Close()`
1026	`}`

func instance.PoolStats

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/redis/wrap.go:

1027	`func (i instance) PoolStats() rdsDrv.PoolStats {`
1028	`return i.GetProxy().PoolStats()`
1029	`}`

Package Overview: github.com/wfusion/gofusion/routine 48.4%

Please select a function to see what's left for testing.

`Construct(...)`	`github.com/wfusion/gofusion/routine/construct.go`	`100.0%`	`32/32`
`startDaemonRoutines(...)`	`github.com/wfusion/gofusion/routine/metrics.go`	`100.0%`	`10/10`
`Promise(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`100.0%`	`6/6`
`addRoutine(...)`	`github.com/wfusion/gofusion/routine/types.go`	`100.0%`	`5/5`
`@91:9(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`100.0%`	`5/5`
`@53:9(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`100.0%`	`5/5`
`Loop(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`100.0%`	`4/4`
`@192:8(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`100.0%`	`4/4`
`Future.GetChan(...)`	`github.com/wfusion/gofusion/routine/future.go`	`100.0%`	`3/3`
`@52:10(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`100.0%`	`3/3`
`addPool(...)`	`github.com/wfusion/gofusion/routine/pool.go`	`100.0%`	`3/3`
`NewPromise(...)`	`github.com/wfusion/gofusion/routine/promise.go`	`100.0%`	`3/3`
`@132:9(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`100.0%`	`3/3`
`@90:10(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`100.0%`	`3/3`
`configs(...)`	`github.com/wfusion/gofusion/routine/construct.go`	`100.0%`	`2/2`
`@240:3(...)`	`github.com/wfusion/gofusion/routine/candy_utils.go`	`100.0%`	`2/2`
`@104:14(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`100.0%`	`2/2`
`Future.OnCancel(...)`	`github.com/wfusion/gofusion/routine/future.go`	`100.0%`	`2/2`
`Future.OnComplete(...)`	`github.com/wfusion/gofusion/routine/future.go`	`100.0%`	`2/2`
`@131:10(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`100.0%`	`2/2`
`Future.OnFailure(...)`	`github.com/wfusion/gofusion/routine/future.go`	`100.0%`	`2/2`
`Future.loadResult(...)`	`github.com/wfusion/gofusion/routine/future.go`	`100.0%`	`2/2`
`Future.loadVal(...)`	`github.com/wfusion/gofusion/routine/future.go`	`100.0%`	`2/2`
`Future.Get(...)`	`github.com/wfusion/gofusion/routine/future.go`	`100.0%`	`2/2`
`@99:10(...)`	`github.com/wfusion/gofusion/routine/candy_utils.go`	`100.0%`	`2/2`
`@71:15(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`100.0%`	`2/2`
`pool.Release(...)`	`github.com/wfusion/gofusion/routine/pool.go`	`100.0%`	`2/2`
`forSlice(...)`	`github.com/wfusion/gofusion/routine/candy_utils.go`	`100.0%`	`2/2`
`@97:10(...)`	`github.com/wfusion/gofusion/routine/candy_utils.go`	`100.0%`	`2/2`
`@38:24(...)`	`github.com/wfusion/gofusion/routine/pool.go`	`100.0%`	`1/1`
`@96:9(...)`	`github.com/wfusion/gofusion/routine/pool.go`	`100.0%`	`1/1`
`@319:8(...)`	`github.com/wfusion/gofusion/routine/future.go`	`100.0%`	`1/1`
`WithoutTimeout(...)`	`github.com/wfusion/gofusion/routine/pool.go`	`100.0%`	`1/1`
`@227:9(...)`	`github.com/wfusion/gofusion/routine/pool.go`	`100.0%`	`1/1`
`promise.Resolve(...)`	`github.com/wfusion/gofusion/routine/promise.go`	`100.0%`	`1/1`
`promise.Reject(...)`	`github.com/wfusion/gofusion/routine/promise.go`	`100.0%`	`1/1`
`AppName(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`100.0%`	`1/1`
`@116:15(...)`	`github.com/wfusion/gofusion/routine/future.go`	`100.0%`	`1/1`
`@43:9(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`100.0%`	`1/1`
`init(...)`	`github.com/wfusion/gofusion/routine/construct.go`	`100.0%`	`1/1`
`forceSync(...)`	`github.com/wfusion/gofusion/routine/construct.go`	`100.0%`	`1/1`
`@37:9(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`100.0%`	`1/1`
`@80:16(...)`	`github.com/wfusion/gofusion/routine/construct.go`	`100.0%`	`1/1`
`Channel(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`100.0%`	`1/1`
`@31:9(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`100.0%`	`1/1`
`WaitGroup(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`100.0%`	`1/1`
`@230:15(...)`	`github.com/wfusion/gofusion/routine/candy_utils.go`	`100.0%`	`1/1`
`@229:11(...)`	`github.com/wfusion/gofusion/routine/candy_utils.go`	`100.0%`	`1/1`
`@25:9(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`100.0%`	`1/1`
`ignoreRecycled(...)`	`github.com/wfusion/gofusion/routine/pool.go`	`100.0%`	`1/1`
`Args(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`100.0%`	`1/1`
`NewPool(...)`	`github.com/wfusion/gofusion/routine/pool.go`	`91.7%`	`11/12`
`allocate(...)`	`github.com/wfusion/gofusion/routine/pool.go`	`89.5%`	`17/19`
`Future.setResult(...)`	`github.com/wfusion/gofusion/routine/future.go`	`88.2%`	`15/17`
`release(...)`	`github.com/wfusion/gofusion/routine/pool.go`	`87.5%`	`14/16`
`Goc(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`87.5%`	`7/8`
`Go(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`87.5%`	`7/8`
`start(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`86.7%`	`13/15`
`delRoutine(...)`	`github.com/wfusion/gofusion/routine/types.go`	`83.3%`	`5/6`
`@132:6(...)`	`github.com/wfusion/gofusion/routine/candy_utils.go`	`80.0%`	`4/5`
`pool.Submit(...)`	`github.com/wfusion/gofusion/routine/pool.go`	`80.0%`	`4/5`
`@74:9(...)`	`github.com/wfusion/gofusion/routine/construct.go`	`77.8%`	`14/18`
`wrapPromise(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`75.0%`	`6/8`
`validate(...)`	`github.com/wfusion/gofusion/routine/pool.go`	`75.0%`	`3/4`
`Future.IsCancelled(...)`	`github.com/wfusion/gofusion/routine/future.go`	`75.0%`	`3/4`
`Future.addCallback(...)`	`github.com/wfusion/gofusion/routine/future.go`	`74.1%`	`20/27`
`@66:21(...)`	`github.com/wfusion/gofusion/routine/metrics.go`	`71.1%`	`32/45`
`@531:7(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`66.7%`	`4/6`
`metricsRuntime(...)`	`github.com/wfusion/gofusion/routine/metrics.go`	`66.7%`	`2/3`
`execCallback(...)`	`github.com/wfusion/gofusion/routine/candy_utils.go`	`63.6%`	`7/11`
`getAct(...)`	`github.com/wfusion/gofusion/routine/candy_utils.go`	`50.0%`	`12/24`
`@146:15(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`50.0%`	`1/2`
`@133:9(...)`	`github.com/wfusion/gofusion/routine/candy_utils.go`	`50.0%`	`1/2`
`@111:15(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`50.0%`	`1/2`
`@64:14(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`50.0%`	`1/2`
`@209:14(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`50.0%`	`1/2`
`getFutureReturnVal(...)`	`github.com/wfusion/gofusion/routine/candy_utils.go`	`40.0%`	`2/5`
`@293:8(...)`	`github.com/wfusion/gofusion/routine/future.go`	`33.3%`	`1/3`
`@241:10(...)`	`github.com/wfusion/gofusion/routine/candy_utils.go`	`33.3%`	`1/3`
`getError(...)`	`github.com/wfusion/gofusion/routine/candy_utils.go`	`25.0%`	`2/8`
`Future.Pipe(...)`	`github.com/wfusion/gofusion/routine/future.go`	`0.0%`	`0/35`
`WhenAnyMatched(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`0.0%`	`0/26`
`@341:6(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`0.0%`	`0/24`
`WhenAll(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`0.0%`	`0/17`
`AggregateError.Error(...)`	`github.com/wfusion/gofusion/routine/candy_utils.go`	`0.0%`	`0/14`
`newErrorWithStacks(...)`	`github.com/wfusion/gofusion/routine/candy_utils.go`	`0.0%`	`0/11`
`whenAllFuture(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`0.0%`	`0/10`
`@233:9(...)`	`github.com/wfusion/gofusion/routine/pool.go`	`0.0%`	`0/8`
`Future.GetOrTimeout(...)`	`github.com/wfusion/gofusion/routine/future.go`	`0.0%`	`0/7`
`WrapFuture(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`0.0%`	`0/7`
`showRoutine(...)`	`github.com/wfusion/gofusion/routine/types.go`	`0.0%`	`0/6`
`Future.SetTimeout(...)`	`github.com/wfusion/gofusion/routine/future.go`	`0.0%`	`0/5`
`@452:6(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`0.0%`	`0/4`
`@462:18(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`0.0%`	`0/4`
`NoMatchedError.HasError(...)`	`github.com/wfusion/gofusion/routine/candy_utils.go`	`0.0%`	`0/4`
`Loopc(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`0.0%`	`0/4`
`@472:17(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`0.0%`	`0/3`
`@160:9(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`0.0%`	`0/3`
`pipe.getPipe(...)`	`github.com/wfusion/gofusion/routine/future.go`	`0.0%`	`0/3`
`@457:17(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`0.0%`	`0/3`
`startPipe(...)`	`github.com/wfusion/gofusion/routine/candy_utils.go`	`0.0%`	`0/3`
`@309:5(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`0.0%`	`0/3`
`@326:8(...)`	`github.com/wfusion/gofusion/routine/future.go`	`0.0%`	`0/3`
`@210:11(...)`	`github.com/wfusion/gofusion/routine/candy_utils.go`	`0.0%`	`0/3`
`@444:19(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`0.0%`	`0/3`
`@107:10(...)`	`github.com/wfusion/gofusion/routine/candy_utils.go`	`0.0%`	`0/2`
`Future.OnSuccess(...)`	`github.com/wfusion/gofusion/routine/future.go`	`0.0%`	`0/2`
`promise.OnSuccess(...)`	`github.com/wfusion/gofusion/routine/promise.go`	`0.0%`	`0/2`
`@209:4(...)`	`github.com/wfusion/gofusion/routine/candy_utils.go`	`0.0%`	`0/2`
`@312:16(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`0.0%`	`0/2`
`@106:5(...)`	`github.com/wfusion/gofusion/routine/future.go`	`0.0%`	`0/2`
`promise.OnComplete(...)`	`github.com/wfusion/gofusion/routine/promise.go`	`0.0%`	`0/2`
`promise.OnFailure(...)`	`github.com/wfusion/gofusion/routine/promise.go`	`0.0%`	`0/2`
`promise.OnCancel(...)`	`github.com/wfusion/gofusion/routine/promise.go`	`0.0%`	`0/2`
`@159:10(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`0.0%`	`0/2`
`@221:18(...)`	`github.com/wfusion/gofusion/routine/future.go`	`0.0%`	`0/2`
`@361:20(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`0.0%`	`0/2`
`writeStrings(...)`	`github.com/wfusion/gofusion/routine/candy_utils.go`	`0.0%`	`0/2`
`pool.ReleaseTimeout(...)`	`github.com/wfusion/gofusion/routine/pool.go`	`0.0%`	`0/2`
`@234:18(...)`	`github.com/wfusion/gofusion/routine/future.go`	`0.0%`	`0/2`
`@315:17(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`0.0%`	`0/2`
`@169:14(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`0.0%`	`0/2`
`@176:15(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`0.0%`	`0/2`
`@104:10(...)`	`github.com/wfusion/gofusion/routine/candy_utils.go`	`0.0%`	`0/2`
`@318:16(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`0.0%`	`0/2`
`@342:10(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`0.0%`	`0/2`
`@139:14(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`0.0%`	`0/2`
`@202:13(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`0.0%`	`0/2`
`@228:18(...)`	`github.com/wfusion/gofusion/routine/future.go`	`0.0%`	`0/1`
`@110:10(...)`	`github.com/wfusion/gofusion/routine/candy_utils.go`	`0.0%`	`0/1`
`@182:15(...)`	`github.com/wfusion/gofusion/routine/candy_utils.go`	`0.0%`	`0/1`
`canceller.Cancel(...)`	`github.com/wfusion/gofusion/routine/future.go`	`0.0%`	`0/1`
`pool.Running(...)`	`github.com/wfusion/gofusion/routine/pool.go`	`0.0%`	`0/1`
`pool.Free(...)`	`github.com/wfusion/gofusion/routine/pool.go`	`0.0%`	`0/1`
`pool.Waiting(...)`	`github.com/wfusion/gofusion/routine/pool.go`	`0.0%`	`0/1`
`pool.Cap(...)`	`github.com/wfusion/gofusion/routine/pool.go`	`0.0%`	`0/1`
`pool.IsClosed(...)`	`github.com/wfusion/gofusion/routine/pool.go`	`0.0%`	`0/1`
`@184:16(...)`	`github.com/wfusion/gofusion/routine/candy_utils.go`	`0.0%`	`0/1`
`@233:12(...)`	`github.com/wfusion/gofusion/routine/future.go`	`0.0%`	`0/1`
`@101:10(...)`	`github.com/wfusion/gofusion/routine/candy_utils.go`	`0.0%`	`0/1`
`@227:12(...)`	`github.com/wfusion/gofusion/routine/future.go`	`0.0%`	`0/1`
`@220:12(...)`	`github.com/wfusion/gofusion/routine/future.go`	`0.0%`	`0/1`
`ignoreMutex(...)`	`github.com/wfusion/gofusion/routine/pool.go`	`0.0%`	`0/1`
`@102:9(...)`	`github.com/wfusion/gofusion/routine/pool.go`	`0.0%`	`0/1`
`@215:18(...)`	`github.com/wfusion/gofusion/routine/future.go`	`0.0%`	`0/1`
`newAggregateError1(...)`	`github.com/wfusion/gofusion/routine/candy_utils.go`	`0.0%`	`0/1`
`@214:12(...)`	`github.com/wfusion/gofusion/routine/future.go`	`0.0%`	`0/1`
`newNoMatchedError1(...)`	`github.com/wfusion/gofusion/routine/candy_utils.go`	`0.0%`	`0/1`
`Timeout(...)`	`github.com/wfusion/gofusion/routine/pool.go`	`0.0%`	`0/1`
`@221:9(...)`	`github.com/wfusion/gofusion/routine/pool.go`	`0.0%`	`0/1`
`newNoMatchedError(...)`	`github.com/wfusion/gofusion/routine/candy_utils.go`	`0.0%`	`0/1`
`@210:12(...)`	`github.com/wfusion/gofusion/routine/future.go`	`0.0%`	`0/1`
`Options(...)`	`github.com/wfusion/gofusion/routine/pool.go`	`0.0%`	`0/1`
`WhenAny(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`0.0%`	`0/1`
`CancelledError.Error(...)`	`github.com/wfusion/gofusion/routine/promise.go`	`0.0%`	`0/1`
`promise.Cancel(...)`	`github.com/wfusion/gofusion/routine/promise.go`	`0.0%`	`0/1`
`@286:15(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`0.0%`	`0/1`
`NoMatchedError.Error(...)`	`github.com/wfusion/gofusion/routine/candy_utils.go`	`0.0%`	`0/1`
`Future.Cancel(...)`	`github.com/wfusion/gofusion/routine/future.go`	`0.0%`	`0/1`
`@118:14(...)`	`github.com/wfusion/gofusion/routine/future.go`	`0.0%`	`0/1`
`@362:14(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`0.0%`	`0/1`
`Future.Canceller(...)`	`github.com/wfusion/gofusion/routine/future.go`	`0.0%`	`0/1`
`canceller.IsCancelled(...)`	`github.com/wfusion/gofusion/routine/future.go`	`0.0%`	`0/1`
`@313:11(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`0.0%`	`0/1`
`@316:11(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`0.0%`	`0/1`
`@319:11(...)`	`github.com/wfusion/gofusion/routine/candy.go`	`0.0%`	`0/1`

func Construct

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/construct.go:

func Construct(ctx context.Context, conf Conf, opts ...utils.OptionExtender) func() {
        opt := utils.ApplyOptions[config.InitOption](opts...)
        optU := utils.ApplyOptions[candyOption](opts...)
        if opt.AppName == "" {
                opt.AppName = optU.appName
        }

        if conf.MaxRoutineAmount <= 0 {
                conf.MaxRoutineAmount = defaultMaxPoolSize
        }

        rwlock.Lock()
        defer rwlock.Unlock()
        if pools == nil {
                pools = make(map[string]map[string]Pool)
        }
        if pools[opt.AppName] == nil {
                pools[opt.AppName] = make(map[string]Pool)
        }
        if ignored == nil {
                ignored = make(map[string]*atomic.Int64)
        }
        if ignored[opt.AppName] == nil {
                ignored[opt.AppName] = atomic.NewInt64(0)
        }
        if idle == nil {
                idle = make(map[string]*atomic.Int64)
        }
        if idle[opt.AppName] == nil {
                idle[opt.AppName] = atomic.NewInt64(int64(conf.MaxRoutineAmount))
        }
        if utils.IsStrNotBlank(conf.Logger) {
                if defaultLogger == nil {
                        defaultLogger = make(map[string]ants.Logger)
                }
                if defaultLogger[opt.AppName] == nil {
                        logger := reflect.New(inspect.TypeOf(conf.Logger)).Interface().(ants.Logger)
                        defaultLogger[opt.AppName] = logger
                        if custom, ok := logger.(customLogger); ok {
                                l := fusLog.Use(conf.LogInstance, fusLog.AppName(opt.AppName))
                                custom.Init(l, opt.AppName)
                        }
                }
        }
        maxReleaseTime := utils.Must(time.ParseDuration(conf.MaxReleaseTimePerPool))

        go startDaemonRoutines(ctx, opt.AppName, &conf)

        return func() {
                rwlock.Lock()
                defer rwlock.Unlock()

                pid := syscall.Getpid()
                app := config.Use(opt.AppName).AppName()
                allExited := func() bool {
                        return idle[opt.AppName].Load() == int64(conf.MaxRoutineAmount)-ignored[opt.AppName].Load()
                }

                // waiting for pool
                if pools != nil {
                        for name, pool := range pools[opt.AppName] {
                                if err := pool.ReleaseTimeout(maxReleaseTime, ignoreMutex()); err != nil {
                                        log.Printf("%v [Gofusion] %s %s exit with releasing pool %s failed because %s",
                                                pid, app, config.ComponentGoroutinePool, name, err)
                                }
                                delete(pools[opt.AppName], name)
                        }
                }

                log.Printf("%v [Gofusion] %s %s pool routines are recycled", pid, app, config.ComponentGoroutinePool)

                // waiting for go
                utils.Timeout(maxReleaseTime, utils.TimeoutWg(&wg))
                log.Printf("%v [Gofusion] %s %s go routines are recycled", pid, app, config.ComponentGoroutinePool)

                if !allExited() {
                        log.Printf("%v [Gofusion] %s %s exit without all goroutines recycled [exists%v]",
                                pid, app, config.ComponentGoroutinePool, showRoutine(opt.AppName))
                }

                delete(ignored, opt.AppName)
                delete(idle, opt.AppName)
                delete(routines, opt.AppName)
        }
}

func startDaemonRoutines

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/metrics.go:

func startDaemonRoutines(ctx context.Context, appName string, conf *Conf) {
        ticker := time.Tick(time.Second * 5)
        app := config.Use(appName).AppName()
        labels := []metrics.Label{}
        lastNumGc := atomic.NewUint32(0)

        log.Printf("%v [Gofusion] %s %s metrics start", syscall.Getpid(), app, config.ComponentGoroutinePool)
        for {
                select {
                case <-ctx.Done():
                        log.Printf("%v [Gofusion] %s %s metrics exited",
                                syscall.Getpid(), app, config.ComponentGoroutinePool)
                        return
                case <-ticker:
                        go metricsRuntime(ctx, appName, lastNumGc, conf, labels)
                }
        }
}

func Promise

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func Promise(fn any, async bool, opts ...utils.OptionExtender) *Future {
        opt := utils.ApplyOptions[candyOption](opts...)
        funcName := utils.GetFuncName(fn)
        allocate(opt.appName, 1, &NewPoolOption{ApplyTimeout: -1}, ignoreRecycled())
        defer func() {
                release(opt.appName, nil, ignoreRecycled())
                delRoutine(opt.appName, funcName)
                if opt.wg != nil {
                        opt.wg.Done()
                }
        }()

        addRoutine(opt.appName, funcName)
        return wrapPromise(fn, async && !forceSync(opt.appName), opts...).
                OnFailure(func(v any) {
                        if opt.ch == nil {
                                log.Printf("[Gofusion] %s catches an error in routine.Loop function: \n"+
                                        "error: %s\nfunc: %s\nfunc signature: %T",
                                        config.ComponentGoroutinePool, v, utils.GetFuncName(fn), fn)
                        }
                }).
                OnComplete(func(v any) {
                        if opt.ch != nil {
                                opt.ch <- v
                        }
                })
}

func addRoutine

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/types.go:

func addRoutine(appName, name string) {
        locker.Lock()
        defer locker.Unlock()

        if _, ok := routines[appName]; !ok {
                routines[appName] = make(map[string]int)
        }
        routines[appName][name]++
}

func @91:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func() {
                        release(opt.appName, nil, nil)
                        delRoutine(opt.appName, funcName)
                        if opt.wg != nil {
                                opt.wg.Done()
                        }
                        wg.Done()
                }

func @53:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func() {
                        release(opt.appName, nil, nil)
                        delRoutine(opt.appName, funcName)
                        if opt.wg != nil {
                                opt.wg.Done()
                        }
                        wg.Done()
                }

func Loop

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func Loop(task any, opts ...utils.OptionExtender) {
        opt := utils.ApplyOptions[candyOption](opts...)
        allocate(opt.appName, 1, &NewPoolOption{ApplyTimeout: -1}, ignoreRecycled())
        exec := func() {
                defer func() {
                        release(opt.appName, nil, ignoreRecycled())
                        if opt.wg != nil {
                                opt.wg.Done()
                        }
                }()
                wrapPromise(task, false, opts...).
                        OnFailure(func(v any) {
                                if opt.ch == nil {
                                        log.Printf("[Gofusion] %s catches an error in routine.Loop function: \n"+
                                                "error: %s\nfunc: %s\nfunc signature: %T",
                                                config.ComponentGoroutinePool, v, utils.GetFuncName(task), task)
                                }
                        }).
                        OnComplete(func(v any) {
                                if opt.ch != nil {
                                        opt.ch <- v
                                }
                        })
        }

        go exec()
}

func @192:8

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func() {
                release(opt.appName, nil, ignoreRecycled())
                delRoutine(opt.appName, funcName)
                if opt.wg != nil {
                        opt.wg.Done()
                }
        }

func Future.GetChan

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

func (f *Future) GetChan() <-chan *Result {
        c := make(chan *Result, 1)
        f.OnComplete(func(v any) {
                c <- f.loadResult()
        }).OnCancel(func() {
                c <- f.loadResult()
        })
        return c
}

func @52:10

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func() {
                defer func() {
                        release(opt.appName, nil, nil)
                        delRoutine(opt.appName, funcName)
                        if opt.wg != nil {
                                opt.wg.Done()
                        }
                        wg.Done()
                }()

                addRoutine(opt.appName, funcName)
                wrapPromise(task, false, opts...).
                        OnFailure(func(v any) {
                                if opt.ch == nil {
                                        log.Printf("[Gofusion] %s catches an error in routine.Go function: \n"+
                                                "error: %s\nfunc: %s\nfunc signature: %T",
                                                config.ComponentGoroutinePool, v, utils.GetFuncName(task), task)
                                }
                        }).
                        OnComplete(func(v any) {
                                if opt.ch != nil {
                                        opt.ch <- v
                                }
                        })
        }

func addPool

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/pool.go:

func addPool(appName, name string, pool Pool) {
        rwlock.Lock()
        defer rwlock.Unlock()
        pools[appName][name] = pool
}

func NewPromise

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/promise.go:

func NewPromise() *promise {
        val := &futureVal{
                dones:   make([]func(v any), 0, 8),
                fails:   make([]func(v any), 0, 8),
                always:  make([]func(v any), 0, 4),
                cancels: make([]func(), 0, 2),
                pipes:   make([]*pipe, 0, 4),
        }
        f := &promise{
                Future: &Future{
                        Id:    rand.Int(),
                        final: make(chan struct{}),
                        val:   unsafe.Pointer(val),
                },
        }
        return f
}

func @132:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func() {
                        release(opt.appName, nil, ignoreRecycled())
                        if opt.wg != nil {
                                opt.wg.Done()
                        }
                }

func @90:10

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func() {
                defer func() {
                        release(opt.appName, nil, nil)
                        delRoutine(opt.appName, funcName)
                        if opt.wg != nil {
                                opt.wg.Done()
                        }
                        wg.Done()
                }()

                addRoutine(opt.appName, funcName)
                select {
                case <-ctx.Done():
                case <-wrapPromise(task, false, opts...).
                        OnFailure(func(v any) {
                                if opt.ch == nil {
                                        log.Printf("[Gofusion] %s catches an error in routine.Goc function: \n"+
                                                "error: %s\nfunc: %s\nfunc signature: %T",
                                                config.ComponentGoroutinePool, v, utils.GetFuncName(task), task)
                                }
                        }).
                        OnComplete(func(v any) {
                                if opt.ch != nil {
                                        opt.ch <- v
                                }
                        }).
                        GetChan():
                }
        }

func configs

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/construct.go:

112	`func configs(appName string) (conf Conf) {`
113	`_ = config.Use(appName).LoadComponentConfig(config.ComponentGoroutinePool, &conf)`
114	`return`
115	`}`

func @240:3

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy_utils.go:

func() {
                        defer func() {
                                if e := recover(); e != nil {
                                        err := newErrorWithStacks(e)
                                        fmt.Println("error happens:\n ", err)
                                }
                        }()
                        f(e)
                }

func @104:14

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func(v any) {
                                if opt.ch == nil {
                                        log.Printf("[Gofusion] %s catches an error in routine.Goc function: \n"+
                                                "error: %s\nfunc: %s\nfunc signature: %T",
                                                config.ComponentGoroutinePool, v, utils.GetFuncName(task), task)
                                }
                        }

func Future.OnCancel

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

187	`func (f Future) OnCancel(callback func()) Future {`
188	`f.addCallback(callback, CallbackCancel)`
189	`return f`
190	`}`

func Future.OnComplete

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

180	`func (f Future) OnComplete(callback func(v any)) Future {`
181	`f.addCallback(callback, CallbackAlways)`
182	`return f`
183	`}`

func @131:10

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func() {
                defer func() {
                        release(opt.appName, nil, ignoreRecycled())
                        if opt.wg != nil {
                                opt.wg.Done()
                        }
                }()
                wrapPromise(task, false, opts...).
                        OnFailure(func(v any) {
                                if opt.ch == nil {
                                        log.Printf("[Gofusion] %s catches an error in routine.Loop function: \n"+
                                                "error: %s\nfunc: %s\nfunc signature: %T",
                                                config.ComponentGoroutinePool, v, utils.GetFuncName(task), task)
                                }
                        }).
                        OnComplete(func(v any) {
                                if opt.ch != nil {
                                        opt.ch <- v
                                }
                        })
        }

func Future.OnFailure

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

170	`func (f Future) OnFailure(callback func(v any)) Future {`
171	`f.addCallback(callback, CallbackFail)`
172	`return f`
173	`}`

func Future.loadResult

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

280	`func (f Future) loadResult() Result {`
281	`val := f.loadVal()`
282	`return val.r`
283	`}`

func Future.loadVal

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

286	`func (f Future) loadVal() futureVal {`
287	`r := atomic.LoadPointer(&f.val)`
288	`return (*futureVal)(r)`
289	`}`

func Future.Get

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

128	`func (f *Future) Get() (val any, err error) {`
129	`<-f.final`
130	`return getFutureReturnVal(f.loadResult())`
131	`}`

func @99:10

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy_utils.go:

99	`func(...any) (any, error) { e := v(); return nil, e }`

func @71:15

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

71	`func(v any) {`
72	`if opt.ch != nil {`
73	`opt.ch <- v`
74	`}`
75	`}`

func pool.Release

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/pool.go:

48	`func (p *pool) Release(opts ...utils.OptionExtender) {`
49	`defer release(p.appName, p, opts...)`
50	`p.pool.Release()`
51	`}`

func forSlice

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy_utils.go:

func forSlice(s []func(v any), f func(func(v any))) {
        for _, e := range s {
                func() {
                        defer func() {
                                if e := recover(); e != nil {
                                        err := newErrorWithStacks(e)
                                        fmt.Println("error happens:\n ", err)
                                }
                        }()
                        f(e)
                }()
        }
}

func @97:10

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy_utils.go:

97	`func(...any) (any, error) { v(); return nil, nil }`

func @38:24

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/pool.go:

38	`func() { e = wrapFn(opt.args...) }`

func @96:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/pool.go:

96	`func(o *internalOption) {`
97	`o.ignoreRecycled = true`
98	`}`

func @319:8

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

319	`func() {`
320	`execCallback(r, v.dones, v.fails, v.always, v.cancels)`
321	`}`

func WithoutTimeout

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/pool.go:

func WithoutTimeout() utils.OptionFunc[NewPoolOption] {
        return func(o *NewPoolOption) {
                o.ApplyTimeout = -1
        }
}

func @227:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/pool.go:

227	`func(o *NewPoolOption) {`
228	`o.ApplyTimeout = -1`
229	`}`

func promise.Resolve

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/promise.go:

56	`func (p *promise) Resolve(v any) (e error) {`
57	`return p.setResult(&Result{v, ResultSuccess})`
58	`}`

func promise.Reject

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/promise.go:

62	`func (p *promise) Reject(err error) (e error) {`
63	`return p.setResult(&Result{err, ResultFailure})`
64	`}`

func AppName

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func AppName(name string) utils.OptionFunc[candyOption] {
        return func(o *candyOption) {
                o.appName = name
        }
}

func @116:15

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

116	`func(v any) {`
117	`c <- f.loadResult()`
118	`}`

func @43:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

43	`func(o *candyOption) {`
44	`o.appName = name`
45	`}`

func init

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/construct.go:

121	`func init() {`
122	`config.AddComponent(config.ComponentGoroutinePool, Construct)`
123	`}`

func forceSync

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/construct.go:

117	`func forceSync(appName string) bool {`
118	`return configs(appName).ForceSync`
119	`}`

func @37:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

37	`func(o *candyOption) {`
38	`o.ch = ch`
39	`}`

func @80:16

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/construct.go:

80	`func() bool {`
81	`return idle[opt.AppName].Load() == int64(conf.MaxRoutineAmount)-ignored[opt.AppName].Load()`
82	`}`

func Channel

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func Channel(ch chan<- any) utils.OptionFunc[candyOption] {
        return func(o *candyOption) {
                o.ch = ch
        }
}

func @31:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

31	`func(o *candyOption) {`
32	`o.wg = wg`
33	`}`

func WaitGroup

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func WaitGroup(wg *sync.WaitGroup) utils.OptionFunc[candyOption] {
        return func(o *candyOption) {
                o.wg = wg
        }
}

func @230:15

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy_utils.go:

230	`func(f func(v any)) { f(r.Result) }`

func @229:11

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy_utils.go:

229	`func(s []func(v any)) {`
230	`forSlice(s, func(f func(v any)) { f(r.Result) })`
231	`}`

func @25:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

25	`func(o *candyOption) {`
26	`o.args = append(o.args, args...)`
27	`}`

func ignoreRecycled

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/pool.go:

func ignoreRecycled() utils.OptionFunc[internalOption] {
        return func(o *internalOption) {
                o.ignoreRecycled = true
        }
}

func Args

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func Args(args ...any) utils.OptionFunc[candyOption] {
        return func(o *candyOption) {
                o.args = append(o.args, args...)
        }
}

func NewPool

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/pool.go:

func NewPool(name string, size int, opts ...utils.OptionExtender) (p Pool) {
        o := utils.ApplyOptions[NewPoolOption](opts...)
        opt := utils.ApplyOptions[candyOption](opts...)
        if o.Logger == nil {
                o.Logger = defaultLogger[opt.appName]
        }

        validate(opt.appName, name)
        allocate(opt.appName, size, o)

        antsPool, err := ants.NewPool(size, ants.WithOptions(ants.Options{
                ExpiryDuration:   o.ExpiryDuration,
                PreAlloc:         o.PreAlloc,
                MaxBlockingTasks: o.MaxBlockingTasks,
                Nonblocking:      o.Nonblocking,
                PanicHandler:     o.PanicHandler,
                Logger:           o.Logger,
                DisablePurge:     o.DisablePurge,
        }))
        if err != nil {
                panic(err)
        }

        p = &pool{appName: opt.appName, name: name, pool: antsPool, option: o}
        addPool(opt.appName, name, p)
        return
}

func allocate

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/pool.go:

func allocate(appName string, size int, o *NewPoolOption, opts ...utils.OptionExtender) {
        oo := utils.ApplyOptions[internalOption](opts...)
        demands := int64(size)
        rwlock.RLock()
        defer rwlock.RUnlock()
        if idle[appName].Load()-demands < 0 && o.ApplyTimeout == 0 {
                panic(ErrPoolOverload)
        }

        if o.ApplyTimeout < 0 {
                o.ApplyTimeout = math.MaxInt64
        }

        t := time.NewTimer(o.ApplyTimeout)
        for {
                select {
                case <-t.C:
                        panic(ErrTimeout)
                default:
                        minuend := idle[appName].Load()
                        diff := minuend - demands
                        // main thread is a goroutine as well, so diff should be greater than 0
                        if diff <= 0 || !idle[appName].CompareAndSwap(minuend, diff) {
                                continue
                        }
                        if oo.ignoreRecycled {
                                ignored[appName].Add(demands)
                        }

                        return
                }
        }
}

func Future.setResult

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

func (f *Future) setResult(r *Result) (e error) {
        defer func() {
                if err := getError(recover()); err != nil {
                        e = err
                        fmt.Printf("\nerror in setResult(): %s\n%s\n", err, debug.Stack())
                }
        }()

        e = errors.New("cannot resolve/reject/cancel more than once")

        for {
                v := f.loadVal()
                if v.r != nil {
                        return
                }
                newVal := *v
                newVal.r = r

                // Use CAS operation to ensure that the state of promise isn't changed.
                // If the state is changed, must get the latest state and try to call CAS again.
                // No ABA issue in this case because address of all objects are different.
                if atomic.CompareAndSwapPointer(&f.val, unsafe.Pointer(v), unsafe.Pointer(&newVal)) {
                        //Close chEnd then all Get() and GetOrTimeout() will be unblocked
                        close(f.final)

                        //call callback functions and start the promise pipeline
                        if len(v.dones) > 0 || len(v.fails) > 0 || len(v.always) > 0 || len(v.cancels) > 0 {
                                Go(func() {
                                        execCallback(r, v.dones, v.fails, v.always, v.cancels)
                                }, AppName(f.AppName))
                        }

                        //start the pipeline
                        if len(v.pipes) > 0 {
                                Go(func() {
                                        for _, pipe := range v.pipes {
                                                pipeTask, pipePromise := pipe.getPipe(r.Typ == ResultSuccess)
                                                startPipe(r, pipeTask, pipePromise)
                                        }
                                }, AppName(f.AppName))
                        }
                        e = nil
                        break
                }
        }
        return
}

func release

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/pool.go:

func release(appName string, p *pool, opts ...utils.OptionExtender) {
        o := utils.ApplyOptions[internalOption](opts...)
        capacity := int64(1)
        if pools == nil || pools[appName] == nil || idle == nil || idle[appName] == nil {
                return
        }

        if p != nil {
                if !o.ignoreMutex {
                        rwlock.Lock()
                        defer rwlock.Unlock()
                }
                delete(pools[appName], p.name)
                capacity = int64(p.pool.Cap())
        }

        alloc := idle[appName]
        if alloc == nil {
                return
        }
        alloc.Add(capacity)
        if o != nil && o.ignoreRecycled {
                alloc.Sub(capacity)
        }
}

func Goc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func Goc(ctx context.Context, task any, opts ...utils.OptionExtender) {
        funcName := utils.GetFuncName(task)
        opt := utils.ApplyOptions[candyOption](opts...)
        allocate(opt.appName, 1, &NewPoolOption{ApplyTimeout: -1})
        exec := func() {
                defer func() {
                        release(opt.appName, nil, nil)
                        delRoutine(opt.appName, funcName)
                        if opt.wg != nil {
                                opt.wg.Done()
                        }
                        wg.Done()
                }()

                addRoutine(opt.appName, funcName)
                select {
                case <-ctx.Done():
                case <-wrapPromise(task, false, opts...).
                        OnFailure(func(v any) {
                                if opt.ch == nil {
                                        log.Printf("[Gofusion] %s catches an error in routine.Goc function: \n"+
                                                "error: %s\nfunc: %s\nfunc signature: %T",
                                                config.ComponentGoroutinePool, v, utils.GetFuncName(task), task)
                                }
                        }).
                        OnComplete(func(v any) {
                                if opt.ch != nil {
                                        opt.ch <- v
                                }
                        }).
                        GetChan():
                }
        }

        wg.Add(1)
        if forceSync(opt.appName) {
                exec()
        } else {
                go exec()
        }
}

func Go

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func Go(task any, opts ...utils.OptionExtender) {
        funcName := utils.GetFuncName(task)
        opt := utils.ApplyOptions[candyOption](opts...)
        allocate(opt.appName, 1, &NewPoolOption{ApplyTimeout: -1})
        exec := func() {
                defer func() {
                        release(opt.appName, nil, nil)
                        delRoutine(opt.appName, funcName)
                        if opt.wg != nil {
                                opt.wg.Done()
                        }
                        wg.Done()
                }()

                addRoutine(opt.appName, funcName)
                wrapPromise(task, false, opts...).
                        OnFailure(func(v any) {
                                if opt.ch == nil {
                                        log.Printf("[Gofusion] %s catches an error in routine.Go function: \n"+
                                                "error: %s\nfunc: %s\nfunc signature: %T",
                                                config.ComponentGoroutinePool, v, utils.GetFuncName(task), task)
                                }
                        }).
                        OnComplete(func(v any) {
                                if opt.ch != nil {
                                        opt.ch <- v
                                }
                        })
        }

        wg.Add(1)
        if forceSync(opt.appName) {
                exec()
        } else {
                go exec()
        }
}

func start

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func start(act any, async bool, opts ...utils.OptionExtender) *Future {
        p := NewPromise()
        if f, ok := act.(*Future); ok {
                return f
        }

        opt := utils.ApplyOptions[candyOption](opts...)
        p.AppName = opt.appName
        if action := getAct(p, act); action != nil {
                if !async {
                        // sync call
                        r, err := action(opt)
                        if p.IsCancelled() {
                                _ = p.Cancel()
                        } else {
                                if err == nil {
                                        _ = p.Resolve(r)
                                } else {
                                        _ = p.Reject(err)
                                }
                        }
                } else {
                        // async call
                        Go(func() {
                                r, err := action(opt)
                                if p.IsCancelled() {
                                        _ = p.Cancel()
                                } else {
                                        if err == nil {
                                                _ = p.Resolve(r)
                                        } else {
                                                _ = p.Reject(err)
                                        }
                                }
                        }, AppName(opt.appName))
                }
        }

        return p.Future
}

func delRoutine

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/types.go:

func delRoutine(appName, name string) {
        locker.Lock()
        defer locker.Unlock()
        if routines == nil || routines[appName] == nil {
                return
        }

        if routines[appName][name]--; routines[appName][name] <= 0 {
                delete(routines, name)
        }
}

func @132:6

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy_utils.go:

func(opt *candyOption) (r any, err error) {
                defer func() {
                        if e := recover(); e != nil {
                                err = newErrorWithStacks(e)
                        }
                }()

                if canCancel {
                        r, err = act2(canceller, opt.args...)
                } else {
                        r, err = act1(opt.args...)
                }

                return
        }

func pool.Submit

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/pool.go:

func (p *pool) Submit(task any, opts ...utils.OptionExtender) (e error) {
        opt := utils.ApplyOptions[candyOption](opts...)
        wrapFn := utils.WrapFunc1[error](task)
        if !forceSync(p.appName) {
                return p.pool.Submit(func() { e = wrapFn(opt.args...) })
        }

        return wrapFn(opt.args...)
}

func @74:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/construct.go:

func() {
                rwlock.Lock()
                defer rwlock.Unlock()

                pid := syscall.Getpid()
                app := config.Use(opt.AppName).AppName()
                allExited := func() bool {
                        return idle[opt.AppName].Load() == int64(conf.MaxRoutineAmount)-ignored[opt.AppName].Load()
                }

                // waiting for pool
                if pools != nil {
                        for name, pool := range pools[opt.AppName] {
                                if err := pool.ReleaseTimeout(maxReleaseTime, ignoreMutex()); err != nil {
                                        log.Printf("%v [Gofusion] %s %s exit with releasing pool %s failed because %s",
                                                pid, app, config.ComponentGoroutinePool, name, err)
                                }
                                delete(pools[opt.AppName], name)
                        }
                }

                log.Printf("%v [Gofusion] %s %s pool routines are recycled", pid, app, config.ComponentGoroutinePool)

                // waiting for go
                utils.Timeout(maxReleaseTime, utils.TimeoutWg(&wg))
                log.Printf("%v [Gofusion] %s %s go routines are recycled", pid, app, config.ComponentGoroutinePool)

                if !allExited() {
                        log.Printf("%v [Gofusion] %s %s exit without all goroutines recycled [exists%v]",
                                pid, app, config.ComponentGoroutinePool, showRoutine(opt.AppName))
                }

                delete(ignored, opt.AppName)
                delete(idle, opt.AppName)
                delete(routines, opt.AppName)
        }

func wrapPromise

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func wrapPromise(fn any, async bool, opts ...utils.OptionExtender) *Future {
        // check supported function
        switch fn.(type) {
        case func(),
                func() error,
                func() (any, error),
                func(Canceller),
                func(Canceller) error,
                func(Canceller) (any, error):

                return start(fn, async, opts...)

        default:
                typ := reflect.TypeOf(fn)
                if typ.Kind() != reflect.Func {
                        return WrapFuture(errors.Errorf("unsupported function type %T", fn), opts...)
                }
                if typ.NumOut() > 0 && (typ.NumOut() > 2 ||
                        typ.Out(typ.NumOut()-1) != constant.ErrorType ||
                        (typ.NumOut() == 2 && typ.Out(0) != constant.AnyType)) {
                        return WrapFuture(errors.Errorf("unsupported function signature %T", fn), opts...)
                }

                return start(fn, async, opts...)
        }
}

func validate

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/pool.go:

func validate(appName, name string) {
        rwlock.RLock()
        defer rwlock.RUnlock()
        if _, ok := pools[appName][name]; ok {
                panic(ErrDuplicatedName)
        }
}

func Future.IsCancelled

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

func (f *Future) IsCancelled() bool {
        val := f.loadVal()

        if val != nil && val.r != nil && val.r.Typ == ResultCancelled {
                return true
        } else {
                return false
        }
}

func Future.addCallback

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

func (f *Future) addCallback(callback any, t callbackType) {
        if callback == nil {
                return
        }
        if (t == CallbackDone) ||
                (t == CallbackFail) ||
                (t == CallbackAlways) {
                if _, ok := callback.(func(v any)); !ok {
                        panic(errors.New("callback function spec must be func(v any)"))
                }
        } else if t == CallbackCancel {
                if _, ok := callback.(func()); !ok {
                        panic(errors.New("callback function spec must be func()"))
                }
        }

        for {
                v := f.loadVal()
                r := v.r
                if r == nil {
                        newVal := *v
                        switch t {
                        case CallbackDone:
                                newVal.dones = append(newVal.dones, callback.(func(v any)))
                        case CallbackFail:
                                newVal.fails = append(newVal.fails, callback.(func(v any)))
                        case CallbackAlways:
                                newVal.always = append(newVal.always, callback.(func(v any)))
                        case CallbackCancel:
                                newVal.cancels = append(newVal.cancels, callback.(func()))
                        }

                        //use CAS to ensure that the state of Future is not changed,
                        //if the state is changed, will retry CAS operation.
                        if atomic.CompareAndSwapPointer(&f.val, unsafe.Pointer(v), unsafe.Pointer(&newVal)) {
                                break
                        }
                } else {
                        if (t == CallbackDone && r.Typ == ResultSuccess) ||
                                (t == CallbackFail && r.Typ == ResultFailure) ||
                                (t == CallbackAlways && r.Typ != ResultCancelled) {
                                callbackFunc := callback.(func(v any))
                                callbackFunc(r.Result)
                        } else if t == CallbackCancel && r.Typ == ResultCancelled {
                                callbackFunc := callback.(func())
                                callbackFunc()
                        }
                        break
                }
        }
}

func @66:21

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/metrics.go:

func() {
                var routineNum int64
                if idle != nil && idle[appName] != nil {
                        routineNum = int64(conf.MaxRoutineAmount) - idle[appName].Load()
                }

                // export number of Goroutines
                totalRoutineNum := runtime.NumGoroutine()

                // export memory stats
                var stats runtime.MemStats
                runtime.ReadMemStats(&stats)

                // export info about the last few GC runs
                // handle wrap around
                if stats.NumGC < lastNumGc.Load() {
                        lastNumGc.Store(0)
                }

                // ensure we don't scan more than 256
                if stats.NumGC-lastNumGc.Load() >= 256 {
                        lastNumGc.Store(stats.NumGC - 255)
                }

                app := config.Use(appName).AppName()
                totalGoRoutinesKey := append([]string{app}, metricsRuntimeTotalGoroutinesKey...)
                goroutineKey := append([]string{app}, metricsRuntimeGoroutinesKey...)
                allocBytesKey := append([]string{app}, metricsRuntimeAllocBytesKey...)
                sysBytesKey := append([]string{app}, metricsRuntimeSysBytesKey...)
                mallocCountKey := append([]string{app}, metricsRuntimeMallocCountKey...)
                freeCountKey := append([]string{app}, metricsRuntimeFreeCountKey...)
                heapObjectsKey := append([]string{app}, metricsRuntimeHeapObjectsKey...)
                gcRunsKey := append([]string{app}, metricsRuntimeGCRunsKey...)
                totalSTWLatencyKey := append([]string{app}, metricsRuntimeTotalSTWLatencyKey...)

                for _, m := range metrics.Internal(metrics.AppName(appName)) {
                        select {
                        case <-ctx.Done():
                                return
                        default:
                                if m.IsEnableServiceLabel() {
                                        m.SetGauge(ctx, totalGoRoutinesKey, float64(totalRoutineNum), metrics.Labels(labels))
                                        m.SetGauge(ctx, goroutineKey, float64(routineNum), metrics.Labels(labels))
                                        m.SetGauge(ctx, allocBytesKey, float64(stats.Alloc), metrics.Labels(labels))
                                        m.SetGauge(ctx, sysBytesKey, float64(stats.Sys), metrics.Labels(labels))
                                        m.SetGauge(ctx, mallocCountKey, float64(stats.Mallocs), metrics.Labels(labels))
                                        m.SetGauge(ctx, freeCountKey, float64(stats.Frees), metrics.Labels(labels))
                                        m.SetGauge(ctx, heapObjectsKey, float64(stats.HeapObjects), metrics.Labels(labels))
                                        m.SetGauge(ctx, gcRunsKey, float64(stats.NumGC), metrics.Labels(labels))
                                        for i := lastNumGc.Load(); i < stats.NumGC; i++ {
                                                m.AddSample(ctx, totalSTWLatencyKey, float64(stats.PauseNs[i%256]), metrics.Labels(labels))
                                        }
                                } else {
                                        m.SetGauge(ctx, metricsRuntimeTotalGoroutinesKey, float64(totalRoutineNum), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsRuntimeGoroutinesKey, float64(routineNum), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsRuntimeAllocBytesKey, float64(stats.Alloc), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsRuntimeSysBytesKey, float64(stats.Sys), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsRuntimeMallocCountKey, float64(stats.Mallocs), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsRuntimeFreeCountKey, float64(stats.Frees), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsRuntimeHeapObjectsKey, float64(stats.HeapObjects), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsRuntimeGCRunsKey, float64(stats.NumGC), metrics.Labels(labels))
                                        for i := lastNumGc.Load(); i < stats.NumGC; i++ {
                                                m.AddSample(ctx, metricsRuntimeTotalSTWLatencyKey, float64(stats.PauseNs[i%256]),
                                                        metrics.Labels(labels),
                                                        metrics.PrometheusBuckets(metricsRuntimeTotalSTWLatencyBuckets),
                                                )
                                        }
                                }
                        }
                }

                lastNumGc.Store(stats.NumGC)
        }

func @531:7

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func() {
                                r, err := action(opt)
                                if p.IsCancelled() {
                                        _ = p.Cancel()
                                } else {
                                        if err == nil {
                                                _ = p.Resolve(r)
                                        } else {
                                                _ = p.Reject(err)
                                        }
                                }
                        }

func metricsRuntime

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/metrics.go:

func metricsRuntime(ctx context.Context, appName string, lastNumGc *atomic.Uint32, conf *Conf, labels []metrics.Label) {
        select {
        case <-ctx.Done():
                return
        default:

        }

        _, _ = utils.Catch(func() {
                var routineNum int64
                if idle != nil && idle[appName] != nil {
                        routineNum = int64(conf.MaxRoutineAmount) - idle[appName].Load()
                }

                // export number of Goroutines
                totalRoutineNum := runtime.NumGoroutine()

                // export memory stats
                var stats runtime.MemStats
                runtime.ReadMemStats(&stats)

                // export info about the last few GC runs
                // handle wrap around
                if stats.NumGC < lastNumGc.Load() {
                        lastNumGc.Store(0)
                }

                // ensure we don't scan more than 256
                if stats.NumGC-lastNumGc.Load() >= 256 {
                        lastNumGc.Store(stats.NumGC - 255)
                }

                app := config.Use(appName).AppName()
                totalGoRoutinesKey := append([]string{app}, metricsRuntimeTotalGoroutinesKey...)
                goroutineKey := append([]string{app}, metricsRuntimeGoroutinesKey...)
                allocBytesKey := append([]string{app}, metricsRuntimeAllocBytesKey...)
                sysBytesKey := append([]string{app}, metricsRuntimeSysBytesKey...)
                mallocCountKey := append([]string{app}, metricsRuntimeMallocCountKey...)
                freeCountKey := append([]string{app}, metricsRuntimeFreeCountKey...)
                heapObjectsKey := append([]string{app}, metricsRuntimeHeapObjectsKey...)
                gcRunsKey := append([]string{app}, metricsRuntimeGCRunsKey...)
                totalSTWLatencyKey := append([]string{app}, metricsRuntimeTotalSTWLatencyKey...)

                for _, m := range metrics.Internal(metrics.AppName(appName)) {
                        select {
                        case <-ctx.Done():
                                return
                        default:
                                if m.IsEnableServiceLabel() {
                                        m.SetGauge(ctx, totalGoRoutinesKey, float64(totalRoutineNum), metrics.Labels(labels))
                                        m.SetGauge(ctx, goroutineKey, float64(routineNum), metrics.Labels(labels))
                                        m.SetGauge(ctx, allocBytesKey, float64(stats.Alloc), metrics.Labels(labels))
                                        m.SetGauge(ctx, sysBytesKey, float64(stats.Sys), metrics.Labels(labels))
                                        m.SetGauge(ctx, mallocCountKey, float64(stats.Mallocs), metrics.Labels(labels))
                                        m.SetGauge(ctx, freeCountKey, float64(stats.Frees), metrics.Labels(labels))
                                        m.SetGauge(ctx, heapObjectsKey, float64(stats.HeapObjects), metrics.Labels(labels))
                                        m.SetGauge(ctx, gcRunsKey, float64(stats.NumGC), metrics.Labels(labels))
                                        for i := lastNumGc.Load(); i < stats.NumGC; i++ {
                                                m.AddSample(ctx, totalSTWLatencyKey, float64(stats.PauseNs[i%256]), metrics.Labels(labels))
                                        }
                                } else {
                                        m.SetGauge(ctx, metricsRuntimeTotalGoroutinesKey, float64(totalRoutineNum), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsRuntimeGoroutinesKey, float64(routineNum), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsRuntimeAllocBytesKey, float64(stats.Alloc), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsRuntimeSysBytesKey, float64(stats.Sys), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsRuntimeMallocCountKey, float64(stats.Mallocs), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsRuntimeFreeCountKey, float64(stats.Frees), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsRuntimeHeapObjectsKey, float64(stats.HeapObjects), metrics.Labels(labels))
                                        m.SetGauge(ctx, metricsRuntimeGCRunsKey, float64(stats.NumGC), metrics.Labels(labels))
                                        for i := lastNumGc.Load(); i < stats.NumGC; i++ {
                                                m.AddSample(ctx, metricsRuntimeTotalSTWLatencyKey, float64(stats.PauseNs[i%256]),
                                                        metrics.Labels(labels),
                                                        metrics.PrometheusBuckets(metricsRuntimeTotalSTWLatencyBuckets),
                                                )
                                        }
                                }
                        }
                }

                lastNumGc.Store(stats.NumGC)
        })
}

func execCallback

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy_utils.go:

func execCallback(r *Result,
        dones []func(v any),
        fails []func(v any),
        always []func(v any),
        cancels []func()) {

        if r.Typ == ResultCancelled {
                for _, f := range cancels {
                        func() {
                                defer func() {
                                        if e := recover(); e != nil {
                                                err := newErrorWithStacks(e)
                                                fmt.Println("error happens:\n ", err)
                                        }
                                }()
                                f()
                        }()
                }
                return
        }

        var callbacks []func(v any)
        if r.Typ == ResultSuccess {
                callbacks = dones
        } else {
                callbacks = fails
        }

        forFs := func(s []func(v any)) {
                forSlice(s, func(f func(v any)) { f(r.Result) })
        }

        forFs(callbacks)
        forFs(always)

}

func getAct

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy_utils.go:

func getAct(p *promise, act any) (f func(opt *candyOption) (r any, err error)) {
        var (
                act1 func(...any) (any, error)
                act2 func(Canceller, ...any) (any, error)
        )
        canCancel := false

        // convert the act to the function that has return value and error if act function haven't return value and error
        switch v := act.(type) {
        case func():
                act1 = func(...any) (any, error) { v(); return nil, nil }
        case func() error:
                act1 = func(...any) (any, error) { e := v(); return nil, e }
        case func() (any, error):
                act1 = func(a ...any) (any, error) { return v() }
        case func(Canceller):
                canCancel = true
                act2 = func(canceller Canceller, a ...any) (any, error) { v(canceller); return nil, nil }
        case func(Canceller) error:
                canCancel = true
                act2 = func(canceller Canceller, a ...any) (any, error) { e := v(canceller); return nil, e }
        case func(Canceller) (any, error):
                canCancel = true
                act2 = func(canceller Canceller, a ...any) (any, error) { return v(canceller) }
        default:
                typ := reflect.TypeOf(v)
                if typ.Kind() == reflect.Func {
                        act1 = utils.WrapFunc2[any, error](v)
                } else {
                        if e, ok := v.(error); !ok {
                                _ = p.Resolve(v)
                        } else {
                                _ = p.Reject(e)
                        }
                        return nil
                }
        }

        // If parameters of act function has a Canceller interface, the Future will be cancelled.
        var canceller Canceller = nil
        if p != nil && canCancel {
                canceller = p.Canceller()
        }

        // return proxy function of act function
        f = func(opt *candyOption) (r any, err error) {
                defer func() {
                        if e := recover(); e != nil {
                                err = newErrorWithStacks(e)
                        }
                }()

                if canCancel {
                        r, err = act2(canceller, opt.args...)
                } else {
                        r, err = act1(opt.args...)
                }

                return
        }
        return
}

func @146:15

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

146	`func(v any) {`
147	`if opt.ch != nil {`
148	`opt.ch <- v`
149	`}`
150	`}`

func @133:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy_utils.go:

func() {
                        if e := recover(); e != nil {
                                err = newErrorWithStacks(e)
                        }
                }

func @111:15

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

111	`func(v any) {`
112	`if opt.ch != nil {`
113	`opt.ch <- v`
114	`}`
115	`}`

func @64:14

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func(v any) {
                                if opt.ch == nil {
                                        log.Printf("[Gofusion] %s catches an error in routine.Go function: \n"+
                                                "error: %s\nfunc: %s\nfunc signature: %T",
                                                config.ComponentGoroutinePool, v, utils.GetFuncName(task), task)
                                }
                        }

func @209:14

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

209	`func(v any) {`
210	`if opt.ch != nil {`
211	`opt.ch <- v`
212	`}`
213	`}`

func getFutureReturnVal

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy_utils.go:

func getFutureReturnVal(r *Result) (any, error) {
        if r.Typ == ResultSuccess {
                return r.Result, nil
        } else if r.Typ == ResultFailure {
                return nil, getError(r.Result)
        } else {
                return nil, getError(r.Result) //&CancelledError{}
        }
}

func @293:8

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

func() {
                if err := getError(recover()); err != nil {
                        e = err
                        fmt.Printf("\nerror in setResult(): %s\n%s\n", err, debug.Stack())
                }
        }

func @241:10

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy_utils.go:

func() {
                                if e := recover(); e != nil {
                                        err := newErrorWithStacks(e)
                                        fmt.Println("error happens:\n ", err)
                                }
                        }

func getError

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy_utils.go:

func getError(i any) (e error) {
        if i != nil {
                switch v := i.(type) {
                case error:
                        e = v
                case string:
                        e = errors.New(v)
                default:
                        if s, ok := i.(stringer); ok {
                                e = errors.New(s.String())
                        } else {
                                e = errors.New(fmt.Sprintf("%v", i))
                        }
                }
        }
        return
}

func Future.Pipe

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

func (f *Future) Pipe(callbacks ...any) (result *Future, ok bool) {
        if len(callbacks) == 0 ||
                (len(callbacks) == 1 && callbacks[0] == nil) ||
                (len(callbacks) > 1 && callbacks[0] == nil && callbacks[1] == nil) {
                result = f
                return
        }

        // ensure all callback functions match the spec "func(v any) *Future"
        cs := make([]func(v any) *Future, len(callbacks), len(callbacks))
        for i, callback := range callbacks {
                switch c := callback.(type) {
                case func(v any) *Future:
                        cs[i] = c
                case func() *Future:
                        cs[i] = func(v any) *Future {
                                return c()
                        }
                case func(v any):
                        cs[i] = func(v any) *Future {
                                return start(func() {
                                        c(v)
                                }, true)
                        }
                case func(v any) (r any, err error):
                        cs[i] = func(v any) *Future {
                                return start(func() (r any, err error) {
                                        r, err = c(v)
                                        return
                                }, true)
                        }
                case func():
                        cs[i] = func(v any) *Future {
                                return start(func() {
                                        c()
                                }, true)
                        }
                case func() (r any, err error):
                        cs[i] = func(v any) *Future {
                                return start(func() (r any, err error) {
                                        r, err = c()
                                        return
                                }, true)
                        }
                default:
                        ok = false
                        return
                }
        }

        for {
                v := f.loadVal()
                r := v.r
                if r != nil {
                        result = f
                        if r.Typ == ResultSuccess && cs[0] != nil {
                                result = cs[0](r.Result)
                        } else if r.Typ == ResultFailure && len(cs) > 1 && cs[1] != nil {
                                result = cs[1](r.Result)
                        }
                } else {
                        newPipe := &pipe{}
                        newPipe.pipeDoneTask = cs[0]
                        if len(cs) > 1 {
                                newPipe.pipeFailTask = cs[1]
                        }
                        newPipe.pipePromise = NewPromise()

                        newVal := *v
                        newVal.pipes = append(newVal.pipes, newPipe)

                        //use CAS to ensure that the state of Future is not changed,
                        //if the state is changed, will retry CAS operation.
                        if atomic.CompareAndSwapPointer(&f.val, unsafe.Pointer(v), unsafe.Pointer(&newVal)) {
                                result = newPipe.pipePromise.Future
                                break
                        }
                }
        }

        ok = true
        return
}

func WhenAnyMatched

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func WhenAnyMatched(predicate func(any) bool, acts ...any) *Future {
        if predicate == nil {
                predicate = func(v any) bool { return true }
        }

        opts := make([]utils.OptionExtender, 0, len(acts))
        for i, act := range acts {
                if opt, ok := act.(utils.OptionExtender); ok {
                        opts = append(opts, opt)
                        acts = append(acts[:i], acts[i+1:]...)
                }
        }
        opt := utils.ApplyOptions[candyOption](opts...)
        fs := make([]*Future, len(acts))
        for i, act := range acts {
                fs[i] = Promise(act, true, opts...)
        }

        nf, rs := NewPromise(), make([]any, len(fs))
        if len(acts) == 0 {
                _ = nf.Resolve(nil)
        }

        chFails, chDones := make(chan anyPromiseResult), make(chan anyPromiseResult)

        Go(func() {
                for i, f := range fs {
                        k := i
                        f.OnSuccess(func(v any) {
                                defer func() { _ = recover() }()
                                chDones <- anyPromiseResult{result: v, i: k}
                        }).OnFailure(func(v any) {
                                defer func() { _ = recover() }()
                                chFails <- anyPromiseResult{result: v, i: k}
                        }).OnCancel(func() {
                                defer func() { _ = recover() }()
                                chFails <- anyPromiseResult{result: ErrCancelled, i: k}
                        })
                }
        }, AppName(opt.appName))

        if len(fs) == 1 {
                select {
                case r := <-chFails:
                        if _, ok := r.result.(CancelledError); ok {
                                _ = nf.Cancel()
                        } else {
                                _ = nf.Reject(newNoMatchedError1(r.result))
                        }
                case r := <-chDones:
                        if predicate(r.result) {
                                _ = nf.Resolve(r.result)
                        } else {
                                _ = nf.Reject(newNoMatchedError1(r.result))
                        }
                }
        } else {
                Go(func() {
                        defer func() {
                                if e := recover(); e != nil {
                                        _ = nf.Reject(newErrorWithStacks(e))
                                }
                        }()

                        j := 0
                        for {
                                select {
                                case r := <-chFails:
                                        rs[r.i] = getError(r.result)
                                case r := <-chDones:
                                        if predicate(r.result) {
                                                // try to cancel other futures
                                                for _, f := range fs {
                                                        _ = f.Cancel()
                                                }

                                                // close the channel for avoid the sender be blocked
                                                closeChan := func(c chan anyPromiseResult) {
                                                        defer func() { _ = recover() }()
                                                        close(c)
                                                }
                                                closeChan(chDones)
                                                closeChan(chFails)

                                                // resolve the future and return result
                                                _ = nf.Resolve(r.result)
                                                return
                                        } else {
                                                rs[r.i] = r.result
                                        }
                                }

                                if j++; j == len(fs) {
                                        m := 0
                                        for _, r := range rs {
                                                switch val := r.(type) {
                                                case CancelledError:
                                                default:
                                                        m++
                                                        _ = val
                                                }
                                        }
                                        if m > 0 {
                                                _ = nf.Reject(newNoMatchedError(rs))
                                        } else {
                                                _ = nf.Cancel()
                                        }
                                        break
                                }
                        }
                }, AppName(opt.appName))
        }
        return nf.Future
}

func @341:6

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func() {
                        defer func() {
                                if e := recover(); e != nil {
                                        _ = nf.Reject(newErrorWithStacks(e))
                                }
                        }()

                        j := 0
                        for {
                                select {
                                case r := <-chFails:
                                        rs[r.i] = getError(r.result)
                                case r := <-chDones:
                                        if predicate(r.result) {
                                                // try to cancel other futures
                                                for _, f := range fs {
                                                        _ = f.Cancel()
                                                }

                                                // close the channel for avoid the sender be blocked
                                                closeChan := func(c chan anyPromiseResult) {
                                                        defer func() { _ = recover() }()
                                                        close(c)
                                                }
                                                closeChan(chDones)
                                                closeChan(chFails)

                                                // resolve the future and return result
                                                _ = nf.Resolve(r.result)
                                                return
                                        } else {
                                                rs[r.i] = r.result
                                        }
                                }

                                if j++; j == len(fs) {
                                        m := 0
                                        for _, r := range rs {
                                                switch val := r.(type) {
                                                case CancelledError:
                                                default:
                                                        m++
                                                        _ = val
                                                }
                                        }
                                        if m > 0 {
                                                _ = nf.Reject(newNoMatchedError(rs))
                                        } else {
                                                _ = nf.Cancel()
                                        }
                                        break
                                }
                        }
                }

func WhenAll

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func WhenAll(acts ...any) (fu *Future) {
        p := NewPromise()
        fu = p.Future

        opts := make([]utils.OptionExtender, 0, len(acts))
        for i, act := range acts {
                if opt, ok := act.(utils.OptionExtender); ok {
                        opts = append(opts, opt)
                        acts = append(acts[:i], acts[i+1:]...)
                }
        }
        opt := utils.ApplyOptions[candyOption](opts...)
        p.AppName = opt.appName
        if len(acts) == 0 {
                _ = p.Resolve([]any{})
                return
        }

        fs := make([]*Future, len(acts))
        for i, act := range acts {
                fs[i] = Promise(act, true, opts...)
        }
        fu = whenAllFuture(fs, opts...)
        return
}

func AggregateError.Error

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy_utils.go:

func (e *AggregateError) Error() string {
        if e.InnerErrs == nil {
                return e.s
        } else {
                buf := bytes.NewBufferString(e.s)
                buf.WriteString("\n\n")
                for i, ie := range e.InnerErrs {
                        if ie == nil {
                                continue
                        }
                        buf.WriteString("error appears in Future ")
                        buf.WriteString(strconv.Itoa(i))
                        buf.WriteString(": ")
                        buf.WriteString(ie.Error())
                        buf.WriteString("\n")
                }
                buf.WriteString("\n")
                return buf.String()
        }
}

func newErrorWithStacks

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy_utils.go:

func newErrorWithStacks(i any) (e error) {
        err := getError(i)
        buf := bytes.NewBufferString(err.Error())
        buf.WriteString("\n")

        pcs := make([]uintptr, 50)
        num := runtime.Callers(2, pcs)
        for _, v := range pcs[0:num] {
                fun := runtime.FuncForPC(v)
                file, line := fun.FileLine(v)
                name := fun.Name()
                writeStrings(buf, []string{name, " ", file, ":", strconv.Itoa(line), "\n"})
        }
        return errors.New(buf.String())
}

func whenAllFuture

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func whenAllFuture(fs []*Future, opts ...utils.OptionExtender) *Future {
        opt := utils.ApplyOptions[candyOption](opts...)
        wf := NewPromise()
        wf.AppName = opt.appName
        rs := make([]any, len(fs))

        if len(fs) == 0 {
                _ = wf.Resolve([]any{})
        } else {
                n := int32(len(fs))
                cancelOthers := func(j int) {
                        for k, f1 := range fs {
                                if k != j {
                                        _ = f1.Cancel()
                                }
                        }
                }

                Go(func() {
                        isCancelled := int32(0)
                        for i, f := range fs {
                                j := i

                                f.OnSuccess(func(v any) {
                                        rs[j] = v
                                        if atomic.AddInt32(&n, -1) == 0 {
                                                _ = wf.Resolve(rs)
                                        }
                                }).OnFailure(func(v any) {
                                        if atomic.CompareAndSwapInt32(&isCancelled, 0, 1) {
                                                // try to cancel all futures
                                                cancelOthers(j)

                                                // errs := make([]error, 0, 1)
                                                // errs = append(errs, v.(error))
                                                e := newAggregateError1("error appears in WhenAll:", v)
                                                _ = wf.Reject(e)
                                        }
                                }).OnCancel(func() {
                                        if atomic.CompareAndSwapInt32(&isCancelled, 0, 1) {
                                                // try to cancel all futures
                                                cancelOthers(j)

                                                _ = wf.Cancel()
                                        }
                                })
                        }
                }, AppName(opt.appName))
        }

        return wf.Future
}

func @233:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/pool.go:

func(o *NewPoolOption) {
                o.ApplyTimeout = in.ApplyTimeout
                o.ExpiryDuration = in.PoolOption.ExpiryDuration
                o.PreAlloc = in.PreAlloc
                o.MaxBlockingTasks = in.MaxBlockingTasks
                o.Nonblocking = in.Nonblocking
                o.PanicHandler = in.PanicHandler
                o.Logger = in.Logger
                o.DisablePurge = in.DisablePurge
        }

func Future.GetOrTimeout

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

func (f *Future) GetOrTimeout(mm uint) (val any, err error, timout bool) {
        if mm == 0 {
                mm = 10
        } else {
                mm = mm * 1000 * 1000
        }

        select {
        case <-time.After((time.Duration)(mm) * time.Nanosecond):
                return nil, nil, true
        case <-f.final:
                r, err := getFutureReturnVal(f.loadResult())
                return r, err, false
        }
}

func WrapFuture

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func WrapFuture(value any, opts ...utils.OptionExtender) *Future {
        opt := utils.ApplyOptions[candyOption](opts...)
        p := NewPromise()
        p.AppName = opt.appName
        if e, ok := value.(error); !ok {
                _ = p.Resolve(value)
        } else {
                _ = p.Reject(e)
        }

        return p.Future
}

func showRoutine

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/types.go:

func showRoutine(appName string) (r []string) {
        locker.RLock()
        defer locker.RUnlock()
        r = make([]string, 0, len(routines[appName]))
        for n, c := range routines[appName] {
                r = append(r, n+":"+strconv.Itoa(c))
        }
        return
}

func Future.SetTimeout

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

func (f *Future) SetTimeout(mm int) *Future {
        if mm == 0 {
                mm = 10
        } else {
                mm = mm * 1000 * 1000
        }

        Go(func() {
                <-time.After((time.Duration)(mm) * time.Nanosecond)
                _ = f.Cancel()
        }, AppName(f.AppName))
        return f
}

func @452:6

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func() {
                        isCancelled := int32(0)
                        for i, f := range fs {
                                j := i

                                f.OnSuccess(func(v any) {
                                        rs[j] = v
                                        if atomic.AddInt32(&n, -1) == 0 {
                                                _ = wf.Resolve(rs)
                                        }
                                }).OnFailure(func(v any) {
                                        if atomic.CompareAndSwapInt32(&isCancelled, 0, 1) {
                                                // try to cancel all futures
                                                cancelOthers(j)

                                                // errs := make([]error, 0, 1)
                                                // errs = append(errs, v.(error))
                                                e := newAggregateError1("error appears in WhenAll:", v)
                                                _ = wf.Reject(e)
                                        }
                                }).OnCancel(func() {
                                        if atomic.CompareAndSwapInt32(&isCancelled, 0, 1) {
                                                // try to cancel all futures
                                                cancelOthers(j)

                                                _ = wf.Cancel()
                                        }
                                })
                        }
                }

func @462:18

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func(v any) {
                                        if atomic.CompareAndSwapInt32(&isCancelled, 0, 1) {
                                                // try to cancel all futures
                                                cancelOthers(j)

                                                // errs := make([]error, 0, 1)
                                                // errs = append(errs, v.(error))
                                                e := newAggregateError1("error appears in WhenAll:", v)
                                                _ = wf.Reject(e)
                                        }
                                }

func NoMatchedError.HasError

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy_utils.go:

func (e *NoMatchedError) HasError() bool {
        for _, ie := range e.Results {
                if _, ok1 := ie.(error); ok1 {
                        return true
                }
        }
        return false
}

func Loopc

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func Loopc(ctx context.Context, task any, opts ...utils.OptionExtender) {
        opt := utils.ApplyOptions[candyOption](opts...)
        allocate(opt.appName, 1, &NewPoolOption{ApplyTimeout: -1}, ignoreRecycled())
        exec := func() {
                defer func() {
                        release(opt.appName, nil, ignoreRecycled())
                        if opt.wg != nil {
                                opt.wg.Done()
                        }
                }()
                select {
                case <-ctx.Done():
                case <-wrapPromise(task, false, opts...).
                        OnFailure(func(v any) {
                                if opt.ch == nil {
                                        log.Printf("[Gofusion] %s catches an error in routine.Loopc function: \n"+
                                                "error: %s\nfunc: %s\nfunc signature: %T",
                                                config.ComponentGoroutinePool, v, utils.GetFuncName(task), task)
                                }
                        }).
                        OnComplete(func(v any) {
                                if opt.ch != nil {
                                        opt.ch <- v
                                }
                        }).
                        GetChan():
                }
        }

        go exec()
}

func @472:17

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func() {
                                        if atomic.CompareAndSwapInt32(&isCancelled, 0, 1) {
                                                // try to cancel all futures
                                                cancelOthers(j)

                                                _ = wf.Cancel()
                                        }
                                }

func @160:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func() {
                        release(opt.appName, nil, ignoreRecycled())
                        if opt.wg != nil {
                                opt.wg.Done()
                        }
                }

func pipe.getPipe

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

func (p *pipe) getPipe(isResolved bool) (func(v any) *Future, *promise) {
        if isResolved {
                return p.pipeDoneTask, p.pipePromise
        } else {
                return p.pipeFailTask, p.pipePromise
        }
}

func @457:17

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

457	`func(v any) {`
458	`rs[j] = v`
459	`if atomic.AddInt32(&n, -1) == 0 {`
460	`_ = wf.Resolve(rs)`
461	`}`
462	`}`

func startPipe

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy_utils.go:

func startPipe(r *Result, pipeTask func(v any) *Future, pipePromise *promise) {
        if pipeTask != nil {
                f := pipeTask(r.Result)
                f.OnSuccess(func(v any) {
                        _ = pipePromise.Resolve(v)
                }).OnFailure(func(v any) {
                        _ = pipePromise.Reject(getError(v))
                })
        }

}

func @309:5

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func() {
                for i, f := range fs {
                        k := i
                        f.OnSuccess(func(v any) {
                                defer func() { _ = recover() }()
                                chDones <- anyPromiseResult{result: v, i: k}
                        }).OnFailure(func(v any) {
                                defer func() { _ = recover() }()
                                chFails <- anyPromiseResult{result: v, i: k}
                        }).OnCancel(func() {
                                defer func() { _ = recover() }()
                                chFails <- anyPromiseResult{result: ErrCancelled, i: k}
                        })
                }
        }

func @326:8

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

func() {
                                        for _, pipe := range v.pipes {
                                                pipeTask, pipePromise := pipe.getPipe(r.Typ == ResultSuccess)
                                                startPipe(r, pipeTask, pipePromise)
                                        }
                                }

func @210:11

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy_utils.go:

func() {
                                        if e := recover(); e != nil {
                                                err := newErrorWithStacks(e)
                                                fmt.Println("error happens:\n ", err)
                                        }
                                }

func @444:19

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

444	`func(j int) {`
445	`for k, f1 := range fs {`
446	`if k != j {`
447	`_ = f1.Cancel()`
448	`}`
449	`}`
450	`}`

func @107:10

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy_utils.go:

107	`func(canceller Canceller, a ...any) (any, error) { e := v(canceller); return nil, e }`

func Future.OnSuccess

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

162	`func (f Future) OnSuccess(callback func(v any)) Future {`
163	`f.addCallback(callback, CallbackDone)`
164	`return f`
165	`}`

func promise.OnSuccess

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/promise.go:

69	`func (p promise) OnSuccess(callback func(v any)) promise {`
70	`p.Future.OnSuccess(callback)`
71	`return p`
72	`}`

func @209:4

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy_utils.go:

func() {
                                defer func() {
                                        if e := recover(); e != nil {
                                                err := newErrorWithStacks(e)
                                                fmt.Println("error happens:\n ", err)
                                        }
                                }()
                                f()
                        }

func @312:16

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

312	`func(v any) {`
313	`defer func() { _ = recover() }()`
314	`chDones <- anyPromiseResult{result: v, i: k}`
315	`}`

func @106:5

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

106	`func() {`
107	`<-time.After((time.Duration)(mm) * time.Nanosecond)`
108	`_ = f.Cancel()`
109	`}`

func promise.OnComplete

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/promise.go:

87	`func (p promise) OnComplete(callback func(v any)) promise {`
88	`p.Future.OnComplete(callback)`
89	`return p`
90	`}`

func promise.OnFailure

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/promise.go:

77	`func (p promise) OnFailure(callback func(v any)) promise {`
78	`p.Future.OnFailure(callback)`
79	`return p`
80	`}`

func promise.OnCancel

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/promise.go:

94	`func (p promise) OnCancel(callback func()) promise {`
95	`p.Future.OnCancel(callback)`
96	`return p`
97	`}`

func @159:10

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func() {
                defer func() {
                        release(opt.appName, nil, ignoreRecycled())
                        if opt.wg != nil {
                                opt.wg.Done()
                        }
                }()
                select {
                case <-ctx.Done():
                case <-wrapPromise(task, false, opts...).
                        OnFailure(func(v any) {
                                if opt.ch == nil {
                                        log.Printf("[Gofusion] %s catches an error in routine.Loopc function: \n"+
                                                "error: %s\nfunc: %s\nfunc signature: %T",
                                                config.ComponentGoroutinePool, v, utils.GetFuncName(task), task)
                                }
                        }).
                        OnComplete(func(v any) {
                                if opt.ch != nil {
                                        opt.ch <- v
                                }
                        }).
                        GetChan():
                }
        }

func @221:18

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

221	`func() (r any, err error) {`
222	`r, err = c(v)`
223	`return`
224	`}`

func @361:20

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

361	`func(c chan anyPromiseResult) {`
362	`defer func() { _ = recover() }()`
363	`close(c)`
364	`}`

func writeStrings

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy_utils.go:

func writeStrings(buf *bytes.Buffer, strings []string) {
        for _, s := range strings {
                buf.WriteString(s)
        }
}

func pool.ReleaseTimeout

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/pool.go:

52	`func (p *pool) ReleaseTimeout(timeout time.Duration, opts ...utils.OptionExtender) error {`
53	`defer release(p.appName, p, opts...)`
54	`return p.pool.ReleaseTimeout(timeout)`
55	`}`

func @234:18

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

234	`func() (r any, err error) {`
235	`r, err = c()`
236	`return`
237	`}`

func @315:17

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

315	`func(v any) {`
316	`defer func() { _ = recover() }()`
317	`chFails <- anyPromiseResult{result: v, i: k}`
318	`}`

func @169:14

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func(v any) {
                                if opt.ch == nil {
                                        log.Printf("[Gofusion] %s catches an error in routine.Loopc function: \n"+
                                                "error: %s\nfunc: %s\nfunc signature: %T",
                                                config.ComponentGoroutinePool, v, utils.GetFuncName(task), task)
                                }
                        }

func @176:15

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

176	`func(v any) {`
177	`if opt.ch != nil {`
178	`opt.ch <- v`
179	`}`
180	`}`

func @104:10

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy_utils.go:

104	`func(canceller Canceller, a ...any) (any, error) { v(canceller); return nil, nil }`

func @318:16

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

318	`func() {`
319	`defer func() { _ = recover() }()`
320	`chFails <- anyPromiseResult{result: ErrCancelled, i: k}`
321	`}`

func @342:10

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func() {
                                if e := recover(); e != nil {
                                        _ = nf.Reject(newErrorWithStacks(e))
                                }
                        }

func @139:14

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func(v any) {
                                if opt.ch == nil {
                                        log.Printf("[Gofusion] %s catches an error in routine.Loop function: \n"+
                                                "error: %s\nfunc: %s\nfunc signature: %T",
                                                config.ComponentGoroutinePool, v, utils.GetFuncName(task), task)
                                }
                        }

func @202:13

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

func(v any) {
                        if opt.ch == nil {
                                log.Printf("[Gofusion] %s catches an error in routine.Loop function: \n"+
                                        "error: %s\nfunc: %s\nfunc signature: %T",
                                        config.ComponentGoroutinePool, v, utils.GetFuncName(fn), fn)
                        }
                }

func @228:18

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

228	`func() {`
229	`c()`
230	`}`

func @110:10

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy_utils.go:

110	`func(canceller Canceller, a ...any) (any, error) { return v(canceller) }`

func @182:15

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy_utils.go:

182	`func(v any) {`
183	`_ = pipePromise.Resolve(v)`
184	`}`

func canceller.Cancel

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

51	`func (c *canceller) Cancel() {`
52	`_ = c.f.Cancel()`
53	`}`

func pool.Running

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/pool.go:

43	`func (p *pool) Running() int { return p.pool.Running() }`

func pool.Free

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/pool.go:

44	`func (p *pool) Free() int { return p.pool.Free() }`

func pool.Waiting

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/pool.go:

45	`func (p *pool) Waiting() int { return p.pool.Waiting() }`

func pool.Cap

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/pool.go:

46	`func (p *pool) Cap() int { return p.pool.Cap() }`

func pool.IsClosed

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/pool.go:

47	`func (p *pool) IsClosed() bool { return p.pool.IsClosed() }`

func @184:16

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy_utils.go:

184	`func(v any) {`
185	`_ = pipePromise.Reject(getError(v))`
186	`}`

func @233:12

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

func(v any) *Future {
                                return start(func() (r any, err error) {
                                        r, err = c()
                                        return
                                }, true)
                        }

func @101:10

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy_utils.go:

101	`func(a ...any) (any, error) { return v() }`

func @227:12

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

func(v any) *Future {
                                return start(func() {
                                        c()
                                }, true)
                        }

func @220:12

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

func(v any) *Future {
                                return start(func() (r any, err error) {
                                        r, err = c(v)
                                        return
                                }, true)
                        }

func ignoreMutex

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/pool.go:

func ignoreMutex() utils.OptionFunc[internalOption] {
        return func(o *internalOption) {
                o.ignoreMutex = true
        }
}

func @102:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/pool.go:

102	`func(o *internalOption) {`
103	`o.ignoreMutex = true`
104	`}`

func @215:18

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

215	`func() {`
216	`c(v)`
217	`}`

func newAggregateError1

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy_utils.go:

67	`func newAggregateError1(s string, e any) *AggregateError {`
68	`return &AggregateError{newErrorWithStacks(s).Error(), []error{getError(e)}}`
69	`}`

func @214:12

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

func(v any) *Future {
                                return start(func() {
                                        c(v)
                                }, true)
                        }

func newNoMatchedError1

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy_utils.go:

36	`func newNoMatchedError1(e any) *NoMatchedError {`
37	`return &NoMatchedError{[]any{e}}`
38	`}`

func Timeout

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/pool.go:

func Timeout(t time.Duration) utils.OptionFunc[NewPoolOption] {
        return func(o *NewPoolOption) {
                o.ApplyTimeout = t
        }
}

func @221:9

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/pool.go:

221	`func(o *NewPoolOption) {`
222	`o.ApplyTimeout = t`
223	`}`

func newNoMatchedError

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy_utils.go:

32	`func newNoMatchedError(results []any) *NoMatchedError {`
33	`return &NoMatchedError{results}`
34	`}`

func @210:12

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

210	`func(v any) *Future {`
211	`return c()`
212	`}`

func Options

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/pool.go:

func Options(in *NewPoolOption) utils.OptionFunc[NewPoolOption] {
        return func(o *NewPoolOption) {
                o.ApplyTimeout = in.ApplyTimeout
                o.ExpiryDuration = in.PoolOption.ExpiryDuration
                o.PreAlloc = in.PreAlloc
                o.MaxBlockingTasks = in.MaxBlockingTasks
                o.Nonblocking = in.Nonblocking
                o.PanicHandler = in.PanicHandler
                o.Logger = in.Logger
                o.DisablePurge = in.DisablePurge
        }
}

func WhenAny

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

270	`func WhenAny(acts ...any) *Future {`
271	`return WhenAnyMatched(nil, acts...)`
272	`}`

func CancelledError.Error

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/promise.go:

16	`func (e *CancelledError) Error() string {`
17	`return "Task be cancelled"`
18	`}`

func promise.Cancel

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/promise.go:

50	`func (p *promise) Cancel() (e error) {`
51	`return p.Future.Cancel()`
52	`}`

func @286:15

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

286	`func(v any) bool { return true }`

func NoMatchedError.Error

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy_utils.go:

19	`func (e *NoMatchedError) Error() string {`
20	`return "No matched future"`
21	`}`

func Future.Cancel

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

155	`func (f *Future) Cancel() (e error) {`
156	`return f.setResult(&Result{ErrCancelled, ResultCancelled})`
157	`}`

func @118:14

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

118	`func() {`
119	`c <- f.loadResult()`
120	`}`

func @362:14

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

362	`func() { _ = recover() }`

func Future.Canceller

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

82	`func (f *Future) Canceller() Canceller {`
83	`return &canceller{f}`
84	`}`

func canceller.IsCancelled

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/future.go:

56	`func (c *canceller) IsCancelled() (r bool) {`
57	`return c.f.IsCancelled()`
58	`}`

func @313:11

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

313	`func() { _ = recover() }`

func @316:11

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

316	`func() { _ = recover() }`

func @319:11

Back

In /Users/windawings/gopath/src/github.com/wfusion/gofusion/routine/candy.go:

319	`func() { _ = recover() }`

Report Total

59.8%

24	`func Construct(ctx context.Context, confs map[string]*Conf, opts ...utils.OptionExtender) func() {`
25	`opt := utils.ApplyOptions[config.InitOption](opts...)`
26	`optU := utils.ApplyOptions[useOption](opts...)`
27	`if opt.AppName == "" {`
28	`opt.AppName = optU.appName`
29	`}`
30
31	`for name, conf := range confs {`
32	`addInstance(ctx, name, conf, opt)`
33	`}`
34	`return func() {`
35	`locker.Lock()`
36	`defer locker.Unlock()`
37
38	`pid := syscall.Getpid()`
39	`app := config.Use(opt.AppName).AppName()`
40	`if consumers != nil {`
41	`for name, router := range consumers[opt.AppName] {`
42	`log.Printf("%v [Gofusion] %s %s %s exiting...", pid, app, config.ComponentAsync, name)`
43	`if err := router.shutdown(); err == nil {`
44	`log.Printf("%v [Gofusion] %s %s %s exited", pid, app, config.ComponentAsync, name)`
45	`} else {`
46	`log.Printf("%v [Gofusion] %s %s %s exit failed: %s", pid, app, config.ComponentAsync, name, err)`
47	`}`
48	`}`
49	`delete(consumers, opt.AppName)`
50	`}`
51
52	`if producers != nil {`
53	`producers[opt.AppName] = make(map[string]Producable, len(producers))`
54	`}`
55	`}`
56	`}`

203	`func (a *asynqConsumer) shutdown() (err error) {`
204	`if a.consumer != nil {`
205	`_, catchErr := utils.Catch(a.consumer.Shutdown)`
206	`err = multierr.Append(err, errors.Cause(catchErr))`
207	`}`
208	`return`
209	`}`

212	`func(ctx context.Context, raw *asynq.Task) (err error) {`
213	`taskName := a.unformatTaskName(raw.Type())`
214	`inspect.SetField(raw, asyncqTaskTypenameField, taskName)`
215	`return next.ProcessTask(ctx, raw)`
216	`}`

228	`func (a *asynqConsumer) adaptAsynqHandlerFunc(h any, typ reflect.Type, embed bool) asynq.HandlerFunc {`
229	`fn := utils.WrapFunc1[error](h)`
230	`return func(ctx context.Context, task *asynq.Task) (err error) {`
231	`ctx, data, _, err := pd.Unseal(task.Payload(), pd.Type(typ))`
232	`if err != nil {`
233	`return`
234	`}`
235	`params := unwrapParams(typ, embed, data)`
236	`return fn(append([]any{ctx}, params...)...)`
237	`}`
238	`}`

211	`func (a *asynqConsumer) gatewayMiddleware(next asynq.Handler) asynq.Handler {`
212	`return asynq.HandlerFunc(func(ctx context.Context, raw *asynq.Task) (err error) {`
213	`taskName := a.unformatTaskName(raw.Type())`
214	`inspect.SetField(raw, asyncqTaskTypenameField, taskName)`
215	`return next.ProcessTask(ctx, raw)`
216	`})`
217	`}`

126	`func AppName(name string) utils.OptionFunc[useOption] {`
127	`return func(o *useOption) {`
128	`o.appName = name`
129	`}`
130	`}`

8	`func wrapParams(fn any) (argType reflect.Type, embed bool) {`
9	`typ := reflect.TypeOf(fn)`
10
11	`inLength := typ.NumIn()`
12	`if inLength == 1 {`
13	`return`
14	`}`
15	`if inLength == 2 {`
16	`return typ.In(1), false`
17	`}`
18
19	`fields := make([]reflect.StructField, 0, inLength)`
20	`for i := 1; i < inLength; i++ {`
21	`fields = append(fields, reflect.StructField{`
22	`Name: fmt.Sprintf("Arg%X", i+1),`
23	`PkgPath: "",`
24	`Type: typ.In(i),`
25	`Tag: "",`
26	`Offset: 0,`
27	`Index: nil,`
28	`Anonymous: false,`
29	`})`
30	`}`
31
32	`return reflect.StructOf(fields), true`
33	`}`

35	`func unwrapParams(typ reflect.Type, embed bool, arg any) (params []any) {`
36	`if typ == nil {`
37	`return`
38	`}`
39
40	`if !embed {`
41	`return []any{arg}`
42	`}`
43
44	`argVal := reflect.Indirect(reflect.ValueOf(arg))`
45	`num := argVal.Type().NumField()`
46	`params = make([]any, 0, num)`
47	`for i := 0; i < num; i++ {`
48	`params = append(params, argVal.Field(i).Interface())`
49	`}`
50
51	`return`
52	`}`

47	`func newAsynqConsumer(ctx context.Context, appName, name string, conf *Conf) Consumable {`
48	`consumer := &asynqConsumer{appName: appName, n: name, c: conf}`
49
50	`var rdsCli rdsDrv.UniversalClient`
51	`switch conf.InstanceType {`
52	`case instanceTypeRedis:`
53	`rdsCli = redis.Use(ctx, conf.Instance, redis.AppName(appName))`
54	`case instanceTypeDB:`
55	`fallthrough`
56	`default:`
57	`panic(errors.Errorf("unknown instance type: %s", conf.InstanceType))`
58	`}`
59
60	`if consumer.logger == nil && utils.IsStrNotBlank(conf.Logger) {`
61	`loggerType := inspect.TypeOf(conf.Logger)`
62	`loggerValue := reflect.New(loggerType)`
63	`if loggerValue.Type().Implements(customLoggerType) {`
64	`logger := log.Use(conf.LogInstance, log.AppName(appName))`
65	`loggerValue.Interface().(customLogger).Init(logger, appName, name)`
66	`}`
67	`consumer.logger = loggerValue.Convert(asynqLoggerType).Interface().(asynq.Logger)`
68	`}`
69
70	`logLevel := asynq.LogLevel(0)`
71	`utils.MustSuccess(logLevel.Set(conf.LogLevel))`
72
73	`consumer.ServeMux = asynq.NewServeMux()`
74	`asynqCfg := asynq.Config{`
75	`Concurrency: conf.ConsumerConcurrency,`
76	`BaseContext: context.Background,`
77	`RetryDelayFunc: asynq.DefaultRetryDelayFunc,`
78	`IsFailure: nil,`
79	`Queues: nil,`
80	`StrictPriority: conf.StrictPriority,`
81	`ErrorHandler: asynq.ErrorHandlerFunc(func(ctx context.Context, task *asynq.Task, err error) {`
82	`taskName := "unknown"`
83	`if task != nil {`
84	`taskName = consumer.unformatTaskName(task.Type())`
85	`}`
86	`consumer.info(ctx, "handle task %s message error %s", taskName, err)`
87	`}),`
88	`Logger: consumer.logger,`
89	`LogLevel: logLevel,`
90	`ShutdownTimeout: 8 * time.Second,`
91	`HealthCheckFunc: func(err error) { consumer.warn(ctx, "health check check failed: %s", err) },`
92	`HealthCheckInterval: 15 * time.Second,`
93	`DelayedTaskCheckInterval: 5 * time.Second,`
94	`GroupGracePeriod: 1 * time.Minute,`
95	`GroupMaxDelay: 0,`
96	`GroupMaxSize: 0,`
97	`GroupAggregator: nil,`
98	`DisableRedisConnClose: true,`
99	`}`
100	`if len(conf.Queues) > 0 {`
101	`asynqCfg.Queues = make(map[string]int, len(conf.Queues))`
102	`for _, queue := range conf.Queues {`
103	`if _, ok := asynqCfg.Queues[queue.Name]; ok {`
104	`panic(ErrDuplicatedQueueName)`
105	`}`
106	`if utils.IsStrBlank(queue.Name) {`
107	`queue.Name = defaultQueue(appName)`
108	`}`
109	`asynqCfg.Queues[queue.Name] = queue.Level`
110	`}`
111	`} else {`
112	`asynqCfg.Queues = map[string]int{defaultQueue(appName): 3}`
113	`}`
114
115	`consumer.consumer = asynq.NewServer(&asynqRedisConnOpt{UniversalClient: rdsCli}, asynqCfg)`
116	`return consumer`
117	`}`

300	`func (a *asynqProducer) Go(fn any, opts ...utils.OptionExtender) (err error) {`
301	`var data any`
302	`opt := utils.ApplyOptions[produceOption](opts...)`
303	`if len(opt.args) > 0 {`
304	`argType, embed := wrapParams(fn)`
305	`data = setParams(argType, embed, opt.args...)`
306	`}`
307
308	`// get task name by func name`
309	`funcName := formatTaskName(a.appName, utils.GetFuncName(fn))`
310	`callbackMapLock.RLock()`
311	`if mappingName, ok := funcNameToTaskName[a.appName][funcName]; ok {`
312	`funcName = mappingName`
313	`}`
314	`callbackMapLock.RUnlock()`
315
316	`ctx := context.Background()`
317	`task, err := a.newTask(ctx, funcName, data)`
318	`if err != nil {`
319	`return`
320	`}`
321
322	`_, err = a.Client.EnqueueContext(ctx, task, a.parseOption(opt)...)`
323	`if err != nil {`
324	`return`
325	`}`
326	`return`
327	`}`

24	`func (a *asynqConsumer) info(ctx context.Context, msg string, args ...any) {`
25	`msg = a.format(msg)`
26	`if a.logger == nil {`
27	`log.Printf(msg, args...)`
28	`} else {`
29	`logArgs := make([]any, 0, len(args)+2)`
30	`logArgs = append(logArgs, ctx, msg)`
31	`logArgs = append(logArgs, args...)`
32	`a.logger.Info(logArgs...)`
33	`}`
34	`}`

125	`func (a *asynqConsumer) Handle(pattern string, fn any, _ ...utils.OptionExtender) {`
126	`if !a.c.Consumer {`
127	`a.debug(context.Background(), "cannot handle task: consumer is not enabled")`
128	`return`
129	`}`
130	`name := formatTaskName(a.appName, pattern)`
131	`funcName := formatTaskName(a.appName, utils.GetFuncName(fn))`
132
133	`callbackMapLock.Lock()`
134	`defer callbackMapLock.Unlock()`
135	`if callbackMap[a.appName] == nil {`
136	`callbackMap[a.appName] = make(map[string]any)`
137	`}`
138	`if funcNameToTaskName[a.appName] == nil {`
139	`funcNameToTaskName[a.appName] = make(map[string]string)`
140	`}`
141	`if _, ok := callbackMap[a.appName][name]; ok {`
142	`panic(ErrDuplicatedHandlerName)`
143	`}`
144	`callbackMap[a.appName][name] = fn`
145	`callbackMap[a.appName][funcName] = fn`
146	`funcNameToTaskName[a.appName][funcName] = name`
147
148	`typ, embed := wrapParams(fn)`
149	`a.ServeMux.Handle(name, a.adaptAsynqHandlerFunc(fn, typ, embed))`
150	`if name != funcName {`
151	`a.ServeMux.Handle(funcName, a.adaptAsynqHandlerFunc(fn, typ, embed))`
152	`}`
153	`}`

190	`func (a *asynqConsumer) Start() (err error) {`
191	`if !a.c.Consumer {`
192	`return ErrConsumerDisabled`
193	`}`
194
195	`defer a.info(context.Background(), "consumer started")`
196
197	`a.ServeMux.Use(a.gatewayMiddleware)`
198	`a.ServeMux.Use(a.mws...)`
199
200	`return a.consumer.Start(a.ServeMux)`
201	`}`

329	`func (a *asynqProducer) Goc(ctx context.Context, fn any, opts ...utils.OptionExtender) (err error) {`
330	`var data any`
331	`opt := utils.ApplyOptions[produceOption](opts...)`
332	`if len(opt.args) > 0 {`
333	`argType, embed := wrapParams(fn)`
334	`data = setParams(argType, embed, opt.args...)`
335	`}`
336
337	`// get task name by func name`
338	`funcName := formatTaskName(a.appName, utils.GetFuncName(fn))`
339	`callbackMapLock.RLock()`
340	`if mappingName, ok := funcNameToTaskName[a.appName][funcName]; ok {`
341	`funcName = mappingName`
342	`}`
343	`callbackMapLock.RUnlock()`
344
345	`task, err := a.newTask(ctx, funcName, data)`
346	`if err != nil {`
347	`return`
348	`}`
349
350	`_, err = a.Client.EnqueueContext(ctx, task, a.parseOption(opt)...)`
351	`if err != nil {`
352	`return`
353	`}`
354	`return`
355	`}`

58	`func addInstance(ctx context.Context, name string, conf Conf, opt config.InitOption) {`
59	`var (`
60	`producer Producable`
61	`consumer Consumable`
62	`)`
63	`switch conf.Type {`
64	`case asyncTypeAsynq:`
65	`if conf.Producer {`
66	`producer = newAsynqProducer(ctx, opt.AppName, name, conf)`
67	`}`
68	`if conf.Consumer {`
69	`consumer = newAsynqConsumer(ctx, opt.AppName, name, conf)`
70	`}`
71	`case asyncTypeMysql:`
72	`fallthrough`
73	`default:`
74	`panic(ErrUnsupportedSchedulerType)`
75	`}`
76
77	`locker.Lock()`
78	`defer locker.Unlock()`
79	`if consumer != nil {`
80	`if consumers == nil {`
81	`consumers = make(map[string]map[string]Consumable)`
82	`}`
83	`if consumers[opt.AppName] == nil {`
84	`consumers[opt.AppName] = make(map[string]Consumable)`
85	`}`
86	`if _, ok := consumers[name]; ok {`
87	`panic(ErrDuplicatedInstanceName)`
88	`}`
89	`consumers[opt.AppName][name] = consumer`
90
91	`// ioc`
92	`if opt.DI != nil {`
93	`opt.DI.MustProvide(`
94	`func() Consumable { return C(name, AppName(opt.AppName)) },`
95	`di.Name(name),`
96	`)`
97	`}`
98	`}`
99
100	`if producer != nil {`
101	`if producers == nil {`
102	`producers = make(map[string]map[string]Producable)`
103	`}`
104	`if producers[opt.AppName] == nil {`
105	`producers[opt.AppName] = make(map[string]Producable)`
106	`}`
107	`if _, ok := producers[name]; ok {`
108	`panic(ErrDuplicatedInstanceName)`
109	`}`
110	`producers[opt.AppName][name] = producer`
111
112	`// ioc`
113	`if opt.DI != nil {`
114	`opt.DI.MustProvide(`
115	`func() Producable { return P(name) },`
116	`di.Name(name),`
117	`)`
118	`}`
119	`}`
120	`}`

148	`func P(name string, opts ...utils.OptionExtender) Producable {`
149	`opt := utils.ApplyOptions[useOption](opts...)`
150
151	`locker.RLock()`
152	`defer locker.RUnlock()`
153	`producers, ok := producers[opt.appName]`
154	`if !ok {`
155	`panic(errors.Errorf("async producer instance not found for app: %s", opt.appName))`
156	`}`
157	`producer, ok := producers[name]`
158	`if !ok {`
159	`panic(errors.Errorf("async producer instance not found for name: %s", name))`
160	`}`
161	`return producer`
162	`}`

132	`func C(name string, opts ...utils.OptionExtender) Consumable {`
133	`opt := utils.ApplyOptions[useOption](opts...)`
134
135	`locker.RLock()`
136	`defer locker.RUnlock()`
137	`consumers, ok := consumers[opt.appName]`
138	`if !ok {`
139	`panic(errors.Errorf("async consumer instance not found for app: %s", opt.appName))`
140	`}`
141	`consumer, ok := consumers[name]`
142	`if !ok {`
143	`panic(errors.Errorf("async consumer instance not found for name: %s", name))`
144	`}`
145	`return consumer`
146	`}`

230	`func(ctx context.Context, task *asynq.Task) (err error) {`
231	`ctx, data, _, err := pd.Unseal(task.Payload(), pd.Type(typ))`
232	`if err != nil {`
233	`return`
234	`}`
235	`params := unwrapParams(typ, embed, data)`
236	`return fn(append([]any{ctx}, params...)...)`
237	`}`

404	`func (a asynqProducer) newTask(ctx context.Context, taskName string, data any) (task asynq.Task, err error) {`
405	`payload, err := pd.Seal(data, pd.Context(ctx), pd.Serialize(a.serializeType), pd.Compress(a.compressType))`
406	`if err != nil {`
407	`return`
408	`}`
409
410	`task = asynq.NewTask(taskName, payload)`
411	`return`
412	`}`

357	`func (a *asynqProducer) Send(ctx context.Context, taskName string, data any, opts ...utils.OptionExtender) (err error) {`
358	`opt := utils.ApplyOptions[produceOption](opts...)`
359	`task, err := a.newTask(ctx, formatTaskName(a.appName, taskName), data)`
360	`if err != nil {`
361	`return`
362	`}`
363
364	`_, err = a.Client.EnqueueContext(ctx, task, a.parseOption(opt)...)`
365	`if err != nil {`
366	`return`
367	`}`
368	`return`
369	`}`

155	`func (a *asynqConsumer) HandleFunc(fn any, _ ...utils.OptionExtender) {`
156	`if !a.c.Consumer {`
157	`a.debug(context.Background(), "cannot handle task: consumer is not enabled")`
158	`return`
159	`}`
160	`funcName := formatTaskName(a.appName, utils.GetFuncName(fn))`
161
162	`callbackMapLock.Lock()`
163	`defer callbackMapLock.Unlock()`
164	`if callbackMap[a.appName] == nil {`
165	`callbackMap[a.appName] = make(map[string]any)`
166	`}`
167	`if funcNameToTaskName[a.appName] == nil {`
168	`funcNameToTaskName[a.appName] = make(map[string]string)`
169	`}`
170	`if _, ok := callbackMap[funcName]; ok {`
171	`panic(ErrDuplicatedHandlerName)`
172	`}`
173	`callbackMap[a.appName][funcName] = fn`
174
175	`typ, embed := wrapParams(fn)`
176	`a.ServeMux.Handle(funcName, a.adaptAsynqHandlerFunc(fn, typ, embed))`
177	`}`

54	`func setParams(typ reflect.Type, embed bool, params ...any) (arg any) {`
55	`if typ == nil {`
56	`return`
57	`}`
58
59	`argValPtr := reflect.New(typ)`
60	`argVal := argValPtr.Elem()`
61	`if !embed {`
62	`if len(params) > 0 {`
63	`argVal.Set(reflect.ValueOf(params[0]))`
64	`}`
65	`return argValPtr.Interface()`
66	`}`
67
68	`for i := 0; i < len(params); i++ {`
69	`ft := argVal.Field(i)`
70	`ft.Set(reflect.ValueOf(params[i]).Convert(ft.Type()))`
71	`}`
72	`return argValPtr.Interface()`
73	`}`

274	`func newAsynqProducer(ctx context.Context, appName, name string, conf *Conf) Producable {`
275	`var rdsCli rdsDrv.UniversalClient`
276	`switch conf.InstanceType {`
277	`case instanceTypeRedis:`
278	`rdsCli = redis.Use(ctx, conf.Instance, redis.AppName(appName))`
279	`case instanceTypeDB:`
280	`fallthrough`
281	`default:`
282	`panic(errors.Errorf("unknown instance type: %s", conf.InstanceType))`
283	`}`
284
285	`producer := &asynqProducer{`
286	`appName: appName,`
287	`n: name,`
288	`c: conf,`
289	`Client: asynq.NewClient(&asynqRedisConnOpt{UniversalClient: rdsCli}),`
290	`compressType: compress.ParseAlgorithm(conf.MessageCompressType),`
291	`serializeType: serialize.ParseAlgorithm(conf.MessageSerializeType),`
292	`}`
293	`// default serialize type`
294	`if !producer.serializeType.IsValid() {`
295	`producer.serializeType = serialize.AlgorithmGob`
296	`}`
297	`return producer`
298	`}`

371	`func (a asynqProducer) parseOption(src produceOption) (dst []asynq.Option) {`
372	`if utils.IsStrNotBlank(src.id) {`
373	`dst = append(dst, asynq.TaskID(src.id))`
374	`}`
375	`if utils.IsStrNotBlank(src.queue) {`
376	`dst = append(dst, asynq.Queue(src.queue))`
377	`} else if len(a.c.Queues) == 1 {`
378	`dst = append(dst, asynq.Queue(a.c.Queues[0].Name))`
379	`} else {`
380	`dst = append(dst, asynq.Queue(defaultQueue(a.appName)))`
381	`}`
382	`if src.maxRetry > 0 {`
383	`dst = append(dst, asynq.MaxRetry(src.maxRetry))`
384	`}`
385	`if !src.deadline.IsZero() {`
386	`dst = append(dst, asynq.Deadline(src.deadline))`
387	`}`
388	`if src.timeout > 0 {`
389	`dst = append(dst, asynq.Timeout(src.timeout))`
390	`}`
391	`if src.delayDuration > 0 {`
392	`dst = append(dst, asynq.ProcessIn(src.timeout))`
393	`}`
394	`if !src.delayTime.IsZero() {`
395	`dst = append(dst, asynq.ProcessAt(src.delayTime))`
396	`}`
397	`if src.retentionDuration > 0 {`
398	`dst = append(dst, asynq.Retention(src.retentionDuration))`
399	`}`
400
401	`return`
402	`}`

12	`func (a *asynqConsumer) debug(ctx context.Context, msg string, args ...any) {`
13	`msg = a.format(msg)`
14	`if a.logger == nil {`
15	`log.Printf(msg, args...)`
16	`} else {`
17	`logArgs := make([]any, 0, len(args)+2)`
18	`logArgs = append(logArgs, ctx, msg)`
19	`logArgs = append(logArgs, args...)`
20	`a.logger.Debug(logArgs...)`
21	`}`
22	`}`

36	`func (a *asynqConsumer) warn(ctx context.Context, msg string, args ...any) {`
37	`msg = a.format(msg)`
38	`if a.logger == nil {`
39	`log.Printf(msg, args...)`
40	`} else {`
41	`logArgs := make([]any, 0, len(args)+2)`
42	`logArgs = append(logArgs, ctx, msg)`
43	`logArgs = append(logArgs, args...)`
44	`a.logger.Warn(logArgs...)`
45	`}`
46	`}`

179	`func (a *asynqConsumer) Serve() (err error) {`
180	`if !a.c.Consumer {`
181	`return ErrConsumerDisabled`
182	`}`
183	`defer a.info(context.Background(), "consumer started")`
184
185	`a.ServeMux.Use(a.gatewayMiddleware)`
186	`a.ServeMux.Use(a.mws...)`
187	`return a.consumer.Run(a.ServeMux)`
188	`}`

119	`func (a *asynqConsumer) Use(mws ...routerMiddleware) {`
120	`for _, mw := range mws {`
121	`a.mws = append(a.mws, a.adaptMiddleware(mw))`
122	`}`
123	`}`

219	`func (a *asynqConsumer) adaptMiddleware(mw routerMiddleware) asynq.MiddlewareFunc {`
220	`return func(asynqNext asynq.Handler) asynq.Handler {`
221	`next := mw(a.adaptRouterHandlerFunc(asynqNext))`
222	`return asynq.HandlerFunc(func(ctx context.Context, t *asynq.Task) error {`
223	`return next(ctx, a.newTask(t))`
224	`})`
225	`}`
226	`}`

240	`func (a *asynqConsumer) adaptRouterHandlerFunc(h asynq.Handler) routerMiddlewareFunc {`
241	`return func(ctx context.Context, raw Task) (err error) {`
242	`return h.ProcessTask(ctx, a.newAsynqTask(raw))`
243	`}`
244	`}`